Switch CoreTabHelper to use WebContentsUserData.

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 "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/instant/instant_loader_delegate.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 24 matching lines @@
   explicit WebContentsDelegateImpl(InstantLoader* loader);
 
   bool is_pointer_down_from_activate() const {
     return is_pointer_down_from_activate_;
   }
 
   // ConstrainedWindowTabHelperDelegate:
   virtual bool ShouldFocusConstrainedWindow() OVERRIDE;
 
   // CoreTabHelperDelegate:
-  virtual void SwapTabContents(TabContents* old_tc,
-                               TabContents* new_tc) OVERRIDE;
+  virtual void SwapTabContents(content::WebContents* old_contents,
+                               content::WebContents* new_contents) OVERRIDE;
 
   // content::WebContentsDelegate:
   virtual bool ShouldSuppressDialogs() OVERRIDE;
   virtual bool ShouldFocusPageAfterCrash() OVERRIDE;
   virtual void LostCapture() OVERRIDE;
   virtual void WebContentsFocused(content::WebContents* contents) OVERRIDE;
   virtual bool CanDownload(content::RenderViewHost* render_view_host,
                            int request_id,
                            const std::string& request_method) OVERRIDE;
   virtual void HandleMouseUp() OVERRIDE;
@@ skipping 41 matching lines @@
 }
 
 bool InstantLoader::WebContentsDelegateImpl::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::WebContentsDelegateImpl::SwapTabContents(
-    TabContents* old_tc,
-    TabContents* new_tc) {
+    content::WebContents* old_contents,
+    content::WebContents* new_contents) {
   // If this is being called, something is swapping in to our
   // |preview_contents_| before we've added it to the tab strip.
-  loader_->ReplacePreviewContents(old_tc, new_tc);
+  loader_->ReplacePreviewContents(old_contents, new_contents);
 }
 
 bool InstantLoader::WebContentsDelegateImpl::ShouldSuppressDialogs() {
   // Any message shown during Instant cancels Instant, so we suppress them.
   return true;
 }
 
 bool InstantLoader::WebContentsDelegateImpl::ShouldFocusPageAfterCrash() {
   return false;
 }
@@ skipping 218 matching lines @@
 
 void InstantLoader::SetupPreviewContents() {
   content::WebContents* new_contents = preview_contents_->web_contents();
   preview_delegate_.reset(new WebContentsDelegateImpl(this));
   WebContentsDelegateImpl* new_delegate = preview_delegate_.get();
   new_contents->SetDelegate(new_delegate);
 
   // Disable popups and such (mainly to avoid losing focus and reverting the
   // preview prematurely).
   preview_contents_->blocked_content_tab_helper()->SetAllContentsBlocked(true);
-  preview_contents_->constrained_window_tab_helper()->set_delegate(
-                                                          new_delegate);
+  preview_contents_->constrained_window_tab_helper()->
+      set_delegate(new_delegate);
   preview_contents_->content_settings()->SetPopupsBlocked(true);
-  preview_contents_->core_tab_helper()->set_delegate(new_delegate);
+  CoreTabHelper::FromWebContents(new_contents)->set_delegate(new_delegate);
   if (ThumbnailGenerator* tg = preview_contents_->thumbnail_generator())
     tg->set_enabled(false);
 
 #if defined(OS_MACOSX)
   // If |preview_contents_| does not currently have a RWHV, we will call
   // SetTakesFocusOnlyOnMouseDown() as a result of the RENDER_VIEW_HOST_CHANGED
   // notification.
   if (content::RenderWidgetHostView* rwhv =
           new_contents->GetRenderWidgetHostView())
     rwhv->SetTakesFocusOnlyOnMouseDown(true);
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
                  content::Source<content::NavigationController>(
                      &new_contents->GetController()));
 #endif
 }
 
 void InstantLoader::CleanupPreviewContents() {
   content::WebContents* old_contents = preview_contents_->web_contents();
   old_contents->SetDelegate(NULL);
   preview_delegate_.reset();
 
   preview_contents_->blocked_content_tab_helper()->SetAllContentsBlocked(false);
   preview_contents_->constrained_window_tab_helper()->set_delegate(NULL);
   preview_contents_->content_settings()->SetPopupsBlocked(false);
-  preview_contents_->core_tab_helper()->set_delegate(NULL);
+  CoreTabHelper::FromWebContents(old_contents)->set_delegate(NULL);
   if (ThumbnailGenerator* tg = preview_contents_->thumbnail_generator())
     tg->set_enabled(true);
 
 #if defined(OS_MACOSX)
   if (content::RenderWidgetHostView* rwhv =
           old_contents->GetRenderWidgetHostView())
     rwhv->SetTakesFocusOnlyOnMouseDown(false);
   registrar_.Remove(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
                     content::Source<content::NavigationController>(
                         &old_contents->GetController()));
 #endif
 }
 
-void InstantLoader::ReplacePreviewContents(TabContents* old_tc,
-                                           TabContents* new_tc) {
-  DCHECK(old_tc == preview_contents_);
+void InstantLoader::ReplacePreviewContents(content::WebContents* old_contents,
+                                           content::WebContents* new_contents) {
+  DCHECK(old_contents == preview_contents_->web_contents());
   CleanupPreviewContents();
   // We release here without deleting so that the caller still has the
   // responsibility for deleting the TabContents.
   ignore_result(preview_contents_.release());
-  preview_contents_.reset(new_tc);
+  preview_contents_.reset(TabContents::FromWebContents(new_contents));
   SetupPreviewContents();
   loader_delegate_->SwappedTabContents(this);
 }