TabContentsWrapper -> TabContents, part 18.

chrome/browser/instant/instant_loader.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/instant/instant_loader.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "chrome/browser/history/history_tab_helper.h"
 #include "chrome/browser/instant/instant_loader_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/tab_contents/thumbnail_generator.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/constrained_window_tab_helper_delegate.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/render_messages.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
@@ skipping 43 matching lines @@
   DCHECK(0 <= usage && usage < PREVIEW_NUM_TYPES);
   // Only track the histogram for the instant loaders, for now.
   if (template_url_id) {
     base::Histogram* histogram = base::LinearHistogram::FactoryGet(
         "Instant.Previews" + group, 1, PREVIEW_NUM_TYPES, PREVIEW_NUM_TYPES + 1,
         base::Histogram::kUmaTargetedHistogramFlag);
     histogram->Add(usage);
   }
 }
 
-SessionStorageNamespace* GetSessionStorageNamespace(TabContentsWrapper* tab) {
+SessionStorageNamespace* GetSessionStorageNamespace(TabContents* tab) {
   return tab->web_contents()->GetController().GetSessionStorageNamespace();
 }
 
 }  // namespace
 
 // static
 const char* const InstantLoader::kInstantHeader = "X-Purpose";
 // static
 const char* const InstantLoader::kInstantHeaderValue = "instant";
 
@@ skipping 134 matching lines @@
                            int request_id,
                            const std::string& request_method) OVERRIDE;
   virtual void HandleMouseUp() OVERRIDE;
   virtual void HandleMouseActivate() OVERRIDE;
   virtual bool OnGoToEntryOffset(int offset) OVERRIDE;
   virtual bool ShouldAddNavigationToHistory(
       const history::HistoryAddPageArgs& add_page_args,
       content::NavigationType navigation_type) OVERRIDE;
 
   // CoreTabHelperDelegate:
-  virtual void SwapTabContents(TabContentsWrapper* old_tc,
-                               TabContentsWrapper* new_tc) OVERRIDE;
+  virtual void SwapTabContents(TabContents* old_tc,
+                               TabContents* new_tc) OVERRIDE;
 
   // ConstrainedWindowTabHelperDelegate:
-  virtual void WillShowConstrainedWindow(TabContentsWrapper* source) OVERRIDE;
+  virtual void WillShowConstrainedWindow(TabContents* source) OVERRIDE;
   virtual bool ShouldFocusConstrainedWindow() OVERRIDE;
 
   // content::WebContentsObserver:
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void DidFailProvisionalLoad(
       int64 frame_id,
       bool is_main_frame,
       const GURL& validated_url,
       int error_code,
       const string16& error_description,
@@ skipping 76 matching lines @@
   args->redirects.clear();
   args->redirects.push_back(url);
 
   // Prune all but the first entry.
   add_page_vector_.erase(add_page_vector_.begin() + 1,
                          add_page_vector_.end());
 }
 
 void InstantLoader::TabContentsDelegateImpl::CommitHistory(
     bool supports_instant) {
-  TabContentsWrapper* tab = loader_->preview_contents();
+  TabContents* tab = loader_->preview_contents();
   if (tab->profile()->IsOffTheRecord())
     return;
 
   for (size_t i = 0; i < add_page_vector_.size(); ++i) {
     tab->history_tab_helper()->UpdateHistoryForNavigation(
       add_page_vector_[i].get());
   }
 
   NavigationEntry* active_entry =
       tab->web_contents()->GetController().GetActiveEntry();
@@ skipping 164 matching lines @@
   if (!waiting_for_new_page_) {
     add_page_vector_.push_back(
         scoped_refptr<history::HistoryAddPageArgs>(add_page_args.Clone()));
   }
   return false;
 }
 
 // If this is being called, something is swapping in to our preview_contents_
 // before we've added it to the tab strip.
 void InstantLoader::TabContentsDelegateImpl::SwapTabContents(
-    TabContentsWrapper* old_tc,
-    TabContentsWrapper* new_tc) {
+    TabContents* old_tc,
+    TabContents* new_tc) {
   loader_->ReplacePreviewContents(old_tc, new_tc);
 }
 
 bool InstantLoader::TabContentsDelegateImpl::ShouldFocusConstrainedWindow() {
   // Return false so that constrained windows are not initially focused. If
   // we did otherwise the preview would prematurely get committed when focus
   // goes to the constrained window.
   return false;
 }
 
 void InstantLoader::TabContentsDelegateImpl::WillShowConstrainedWindow(
-    TabContentsWrapper* source) {
+    TabContents* source) {
   if (!loader_->ready()) {
     // A constrained window shown for an auth may not paint. Show the preview
     // contents.
     UnregisterForPaintNotifications();
     loader_->ShowPreview();
   }
 }
 
 bool InstantLoader::TabContentsDelegateImpl::OnMessageReceived(
     const IPC::Message& message) {
@@ skipping 19 matching lines @@
     // instant active). To ensure the download happens when the user presses
     // enter we set needs_reload_ to true, which triggers a reload.
     loader_->needs_reload_ = true;
   }
 }
 
 void InstantLoader::TabContentsDelegateImpl::OnSetSuggestions(
     int32 page_id,
     const std::vector<std::string>& suggestions,
     InstantCompleteBehavior behavior) {
-  TabContentsWrapper* source = loader_->preview_contents();
+  TabContents* source = loader_->preview_contents();
   NavigationEntry* entry =
       source->web_contents()->GetController().GetActiveEntry();
   if (!entry || page_id != entry->GetPageID())
     return;
 
   if (suggestions.empty())
     loader_->SetCompleteSuggestedText(string16(), behavior);
   else
     loader_->SetCompleteSuggestedText(UTF8ToUTF16(suggestions[0]), behavior);
 }
@@ skipping 37 matching lines @@
       http_status_ok_(true),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
       verbatim_(false),
       needs_reload_(false),
       group_(group) {
 }
 
 InstantLoader::~InstantLoader() {
   registrar_.RemoveAll();
 
-  // Delete the TabContentsWrapper before the delegate as the TabContentsWrapper
+  // Delete the TabContents before the delegate as the TabContents
   // holds a reference to the delegate.
   if (preview_contents())
     AddPreviewUsageForHistogram(template_url_id_, PREVIEW_DELETED, group_);
   preview_contents_.reset();
 }
 
-bool InstantLoader::Update(TabContentsWrapper* tab_contents,
+bool InstantLoader::Update(TabContents* tab_contents,
                            const TemplateURL* template_url,
                            const GURL& url,
                            content::PageTransition transition_type,
                            const string16& user_text,
                            bool verbatim,
                            string16* suggested_text) {
   DCHECK(!url.is_empty() && url.is_valid());
 
   // Strip leading ?.
   string16 new_user_text =
@@ skipping 100 matching lines @@
           this, &InstantLoader::ProcessBoundsChange);
     }
   }
 }
 
 bool InstantLoader::IsMouseDownFromActivate() {
   return preview_tab_contents_delegate_.get() &&
       preview_tab_contents_delegate_->is_mouse_down_from_activate();
 }
 
-TabContentsWrapper* InstantLoader::ReleasePreviewContents(
+TabContents* InstantLoader::ReleasePreviewContents(
     InstantCommitType type,
-    TabContentsWrapper* tab_contents) {
+    TabContents* tab_contents) {
   if (!preview_contents_.get())
     return NULL;
 
   // FrameLoadObserver is only used for instant results, and instant results are
   // only committed if active (when the FrameLoadObserver isn't installed).
   DCHECK(type == INSTANT_COMMIT_DESTROY || !frame_load_observer_.get());
 
   if (type != INSTANT_COMMIT_DESTROY && is_showing_instant()) {
     RenderViewHost* host =
         preview_contents_->web_contents()->GetRenderViewHost();
@@ skipping 55 matching lines @@
 }
 
 bool InstantLoader::ShouldCommitInstantOnMouseUp() {
   return delegate_->ShouldCommitInstantOnMouseUp();
 }
 
 void InstantLoader::CommitInstantLoader() {
   delegate_->CommitInstantLoader(this);
 }
 
-void InstantLoader::MaybeLoadInstantURL(TabContentsWrapper* tab_contents,
+void InstantLoader::MaybeLoadInstantURL(TabContents* tab_contents,
                                         const TemplateURL* template_url) {
   DCHECK(template_url_id_ == template_url->id());
 
   // If we already have a |preview_contents_|, future search queries will be
   // issued into it (see the "if (!created_preview_contents)" block in |Update|
   // above), so there is no need to load the |template_url|'s instant URL.
   if (preview_contents_.get())
     return;
 
   CreatePreviewContents(tab_contents);
@@ skipping 161 matching lines @@
   if (preview_contents_.get() && is_showing_instant() &&
       (force_if_waiting || !is_determining_if_page_supports_instant())) {
     last_omnibox_bounds_ = omnibox_bounds_;
     RenderViewHost* host =
         preview_contents_->web_contents()->GetRenderViewHost();
     host->Send(new ChromeViewMsg_SearchBoxResize(
         host->GetRoutingID(), GetOmniboxBoundsInTermsOfPreview()));
   }
 }
 
-void InstantLoader::ReplacePreviewContents(TabContentsWrapper* old_tc,
-                                           TabContentsWrapper* new_tc) {
+void InstantLoader::ReplacePreviewContents(TabContents* old_tc,
+                                           TabContents* new_tc) {
   DCHECK(old_tc == preview_contents_);
   // We release here without deleting so that the caller still has reponsibility
-  // for deleting the TabContentsWrapper.
+  // for deleting the TabContents.
   ignore_result(preview_contents_.release());
   preview_contents_.reset(new_tc);
   session_storage_namespace_ = GetSessionStorageNamespace(new_tc);
 
   // Make sure the new preview contents acts like the old one.
   SetupPreviewContents(old_tc);
 
   // Cleanup the old preview contents.
   old_tc->constrained_window_tab_helper()->set_delegate(NULL);
   old_tc->core_tab_helper()->set_delegate(NULL);
@@ skipping 13 matching lines @@
           &old_tc->web_contents()->GetController()));
 
   // We prerendered so we should be ready to show. If we're ready, swap in
   // immediately, otherwise show the preview as normal.
   if (ready_)
     delegate_->SwappedTabContents(this);
   else
     ShowPreview();
 }
 
-void InstantLoader::SetupPreviewContents(TabContentsWrapper* tab_contents) {
+void InstantLoader::SetupPreviewContents(TabContents* tab_contents) {
   preview_contents_->web_contents()->SetDelegate(
       preview_tab_contents_delegate_.get());
   preview_contents_->blocked_content_tab_helper()->SetAllContentsBlocked(true);
   preview_contents_->constrained_window_tab_helper()->set_delegate(
       preview_tab_contents_delegate_.get());
   preview_contents_->core_tab_helper()->set_delegate(
       preview_tab_contents_delegate_.get());
   // Disables thumbnailing while the web contents is shown as preview to avoid
   // generating unnecessary thumbnails.
   if (preview_contents_->thumbnail_generator())
@@ skipping 18 matching lines @@
       this,
       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(
           &preview_contents_->web_contents()->GetController()));
 
   gfx::Rect tab_bounds;
   tab_contents->web_contents()->GetView()->GetContainerBounds(&tab_bounds);
   preview_contents_->web_contents()->GetView()->SizeContents(tab_bounds.size());
 }
 
-void InstantLoader::CreatePreviewContents(TabContentsWrapper* tab_contents) {
+void InstantLoader::CreatePreviewContents(TabContents* tab_contents) {
   WebContents* new_contents = WebContents::Create(
       tab_contents->profile(), NULL, MSG_ROUTING_NONE, NULL, NULL);
-  preview_contents_.reset(new TabContentsWrapper(new_contents));
+  preview_contents_.reset(new TabContents(new_contents));
   AddPreviewUsageForHistogram(template_url_id_, PREVIEW_CREATED, group_);
   session_storage_namespace_ = GetSessionStorageNamespace(tab_contents);
   preview_tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
   SetupPreviewContents(tab_contents);
 
   preview_contents_->web_contents()->ShowContents();
 }
 
 void InstantLoader::LoadInstantURL(const TemplateURL* template_url,
                                    content::PageTransition transition_type,
@@ skipping 29 matching lines @@
     host->Send(new ChromeViewMsg_SearchBoxResize(
         host->GetRoutingID(), GetOmniboxBoundsInTermsOfPreview()));
   } else {
     host->Send(new ChromeViewMsg_SearchBoxChange(
         host->GetRoutingID(), user_text, verbatim, 0, 0));
   }
 
   frame_load_observer_.reset(new FrameLoadObserver(
       this, preview_contents()->web_contents(), user_text, verbatim));
 }