TabContentsWrapper -> TabContents, part 23.

chrome/browser/prerender/prerender_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/prerender/prerender_manager.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 16 matching lines @@
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_history.h"
 #include "chrome/browser/prerender/prerender_local_predictor.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/prerender/prerender_tab_helper.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/prerender_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 69 matching lines @@
 }
 
 }  // namespace
 
 class PrerenderManager::OnCloseTabContentsDeleter
     : public content::WebContentsDelegate,
       public base::SupportsWeakPtr<
           PrerenderManager::OnCloseTabContentsDeleter> {
  public:
   OnCloseTabContentsDeleter(PrerenderManager* manager,
-                            TabContentsWrapper* tab)
+                            TabContents* tab)
       : manager_(manager),
         tab_(tab) {
     tab_->web_contents()->SetDelegate(this);
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         base::Bind(&OnCloseTabContentsDeleter::ScheduleTabContentsForDeletion,
                    this->AsWeakPtr(), true),
         base::TimeDelta::FromSeconds(kDeleteWithExtremePrejudiceSeconds));
   }
 
   virtual void CloseContents(WebContents* source) OVERRIDE {
@@ skipping 13 matching lines @@
  private:
   static const int kDeleteWithExtremePrejudiceSeconds = 3;
 
   void ScheduleTabContentsForDeletion(bool timeout) {
     tab_->web_contents()->SetDelegate(NULL);
     manager_->ScheduleDeleteOldTabContents(tab_.release(), this);
     UMA_HISTOGRAM_BOOLEAN("Prerender.TabContentsDeleterTimeout", timeout);
   }
 
   PrerenderManager* manager_;
-  scoped_ptr<TabContentsWrapper> tab_;
+  scoped_ptr<TabContents> tab_;
 
   DISALLOW_COPY_AND_ASSIGN(OnCloseTabContentsDeleter);
 };
 
 // static
 bool PrerenderManager::is_prefetch_enabled_ = false;
 
 // static
 int PrerenderManager::prerenders_per_session_count_ = 0;
 
@@ skipping 229 matching lines @@
   }
 
   histograms_->RecordPerSessionCount(++prerenders_per_session_count_);
   histograms_->RecordUsedPrerender(prerender_contents->origin());
   prerender_contents->set_final_status(FINAL_STATUS_USED);
 
   new_render_view_host->Send(
       new PrerenderMsg_SetIsPrerendering(new_render_view_host->GetRoutingID(),
                                          false));
 
-  TabContentsWrapper* new_tab_contents =
+  TabContents* new_tab_contents =
       prerender_contents->ReleasePrerenderContents();
-  TabContentsWrapper* old_tab_contents =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
+  TabContents* old_tab_contents = TabContents::FromWebContents(web_contents);
   DCHECK(new_tab_contents);
   DCHECK(old_tab_contents);
 
   MarkWebContentsAsPrerendered(new_tab_contents->web_contents());
 
   // Merge the browsing history.
   new_tab_contents->web_contents()->GetController().CopyStateFromAndPrune(
       &old_tab_contents->web_contents()->GetController());
   old_tab_contents->core_tab_helper()->delegate()->
       SwapTabContents(old_tab_contents, new_tab_contents);
@@ skipping 194 matching lines @@
 bool PrerenderManager::IsNoUseGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
 }
 
 bool PrerenderManager::IsWebContentsPrerendering(
     WebContents* web_contents) const {
   DCHECK(CalledOnValidThread());
   for (PrerenderContentsDataList::const_iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
-    TabContentsWrapper* prerender_tab_contents_wrapper =
-        it->contents_->prerender_contents();
-    if (prerender_tab_contents_wrapper &&
-        prerender_tab_contents_wrapper->web_contents() == web_contents) {
+    TabContents* prerender_tab_contents = it->contents_->prerender_contents();
+    if (prerender_tab_contents &&
+        prerender_tab_contents->web_contents() == web_contents) {
       return true;
     }
   }
 
   // Also look through the pending-deletion list.
   for (std::list<PrerenderContents*>::const_iterator it =
            pending_delete_list_.begin();
        it != pending_delete_list_.end();
        ++it) {
-    TabContentsWrapper* prerender_tab_contents_wrapper =
-        (*it)->prerender_contents();
-    if (prerender_tab_contents_wrapper &&
-        prerender_tab_contents_wrapper->web_contents() == web_contents)
+    TabContents* prerender_tab_contents = (*it)->prerender_contents();
+    if (prerender_tab_contents &&
+        prerender_tab_contents->web_contents() == web_contents)
       return true;
   }
 
   return false;
 }
 
 bool PrerenderManager::DidPrerenderFinishLoading(const GURL& url) const {
   DCHECK(CalledOnValidThread());
   PrerenderContents* contents = FindEntry(url);
   return contents ? contents->has_finished_loading() : false;
@@ skipping 433 matching lines @@
       GetCurrentTimeTicks() - last_prerender_start_time_;
   histograms_->RecordTimeBetweenPrerenderRequests(elapsed_time);
   if (!config_.rate_limit_enabled)
     return true;
   return elapsed_time >
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 }
 
 void PrerenderManager::DeleteOldTabContents() {
   while (!old_tab_contents_list_.empty()) {
-    TabContentsWrapper* tab_contents = old_tab_contents_list_.front();
+    TabContents* tab_contents = old_tab_contents_list_.front();
     old_tab_contents_list_.pop_front();
     // TODO(dominich): should we use Instant Unload Handler here?
     delete tab_contents;
   }
 }
 
 void PrerenderManager::CleanUpOldNavigations() {
   DCHECK(CalledOnValidThread());
 
   // Cutoff.  Navigations before this cutoff can be discarded.
   base::TimeTicks cutoff = GetCurrentTimeTicks() -
       base::TimeDelta::FromMilliseconds(kNavigationRecordWindowMs);
   while (!navigations_.empty()) {
     if (navigations_.front().time_ > cutoff)
       break;
     navigations_.pop_front();
   }
 }
 
 void PrerenderManager::ScheduleDeleteOldTabContents(
-    TabContentsWrapper* tab,
+    TabContents* tab,
     OnCloseTabContentsDeleter* deleter) {
   old_tab_contents_list_.push_back(tab);
   PostCleanupTask();
 
   if (deleter) {
     ScopedVector<OnCloseTabContentsDeleter>::iterator i = std::find(
         on_close_tab_contents_deleters_.begin(),
         on_close_tab_contents_deleters_.end(),
         deleter);
     DCHECK(i != on_close_tab_contents_deleters_.end());
@@ skipping 79 matching lines @@
   if (!render_process_host || !render_process_host->GetBrowserContext())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->GetBrowserContext());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender