Remove two functions on WebContentsDelegate which didn't belong in content. They were only called f…

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"
 #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.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 
+namespace {
+
+static int kUserDataKey;

[sreeram, 2012/09/25 22:51:48]

I don't think static adds any value, since this is in an anonymous namespace
already.

+
+class InstantLoaderUserData : public base::SupportsUserData::Data {
+ public:
+  explicit InstantLoaderUserData(InstantLoader* loader) : loader_(loader) {}
+  virtual ~InstantLoaderUserData() {}
+
+  InstantLoader* loader() const { return loader_; }
+
+ private:
+  InstantLoader* loader_;
+  DISALLOW_COPY_AND_ASSIGN(InstantLoaderUserData);

[sreeram, 2012/09/25 22:51:48]

This (and line 109) could instead be DISALLOW_IMPLICIT_CONSTRUCTORS().

+};
+
+}
+
 // WebContentsDelegateImpl -----------------------------------------------------
 
 class InstantLoader::WebContentsDelegateImpl
     : public ConstrainedWindowTabHelperDelegate,
       public CoreTabHelperDelegate,
       public content::WebContentsDelegate,
       public content::WebContentsObserver {
  public:
   explicit WebContentsDelegateImpl(InstantLoader* loader);
 
@@ skipping 15 matching lines @@
   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;
   virtual void HandlePointerActivate() OVERRIDE;
   virtual void HandleGestureBegin() OVERRIDE;
   virtual void HandleGestureEnd() OVERRIDE;
   virtual void DragEnded() OVERRIDE;
   virtual bool OnGoToEntryOffset(int offset) OVERRIDE;
-  virtual bool ShouldAddNavigationToHistory(
-      const history::HistoryAddPageArgs& add_page_args,
-      content::NavigationType navigation_type) OVERRIDE;
 
   // content::WebContentsObserver:
   virtual void DidFinishLoad(
       int64 frame_id,
       const GURL& validated_url,
       bool is_main_frame,
       content::RenderViewHost* render_view_host) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
  private:
@@ skipping 87 matching lines @@
   // If the user drags, we won't get a mouse up (at least on Linux). Commit the
   // Instant result when the drag ends, so that during the drag the page won't
   // move around.
   CommitFromPointerReleaseIfNecessary();
 }
 
 bool InstantLoader::WebContentsDelegateImpl::OnGoToEntryOffset(int offset) {
   return false;
 }
 
-bool InstantLoader::WebContentsDelegateImpl::ShouldAddNavigationToHistory(
-    const history::HistoryAddPageArgs& add_page_args,
-    content::NavigationType navigation_type) {
-  loader_->last_navigation_ = add_page_args;
-  return false;
-}
-
 void InstantLoader::WebContentsDelegateImpl::DidFinishLoad(
     int64 frame_id,
     const GURL& validated_url,
     bool is_main_frame,
     content::RenderViewHost* render_view_host) {
   if (is_main_frame) {
     if (!loader_->supports_instant_)
       Send(new ChromeViewMsg_DetermineIfPageSupportsInstant(routing_id()));
     loader_->loader_delegate_->InstantLoaderPreviewLoaded(loader_);
   }
@@ skipping 85 matching lines @@
     Observe(NULL);
   }
 
   loader_->supports_instant_ = supports_instant;
   loader_->loader_delegate_->InstantSupportDetermined(loader_,
                                                       supports_instant);
 }
 
 // InstantLoader ---------------------------------------------------------------
 
+// static
+InstantLoader* InstantLoader::FromWebContents(
+    content::WebContents* web_contents) {
+  InstantLoaderUserData* data = static_cast<InstantLoaderUserData*>(
+      web_contents->GetUserData(&kUserDataKey));
+  return data ? data->loader() : NULL;
+}
+
 InstantLoader::InstantLoader(InstantLoaderDelegate* delegate,
                              const std::string& instant_url,
                              const TabContents* tab_contents)
     : loader_delegate_(delegate),
       preview_contents_(
           TabContents::Factory::CreateTabContents(
               content::WebContents::CreateWithSessionStorage(
                   tab_contents->profile(), NULL, MSG_ROUTING_NONE,
                   tab_contents->web_contents(),
                   tab_contents->web_contents()->GetController().
@@ skipping 39 matching lines @@
                                                            results));
 }
 
 void InstantLoader::OnUpOrDownKeyPressed(int count) {
   content::RenderViewHost* rvh =
       preview_contents_->web_contents()->GetRenderViewHost();
   rvh->Send(new ChromeViewMsg_SearchBoxUpOrDownKeyPressed(rvh->GetRoutingID(),
                                                           count));
 }
 
+void InstantLoader::DidNavigate(
+    const history::HistoryAddPageArgs& add_page_args) {
+  last_navigation_ = add_page_args;
+}
+
 TabContents* InstantLoader::ReleasePreviewContents(InstantCommitType type,
                                                    const string16& text) {
   content::RenderViewHost* rvh =
       preview_contents_->web_contents()->GetRenderViewHost();
   if (type == INSTANT_COMMIT_PRESSED_ENTER)
     rvh->Send(new ChromeViewMsg_SearchBoxSubmit(rvh->GetRoutingID(), text));
   else
     rvh->Send(new ChromeViewMsg_SearchBoxCancel(rvh->GetRoutingID(), text));
   CleanupPreviewContents();
+  preview_contents_->web_contents()->RemoveUserData(&kUserDataKey);
   return preview_contents_.release();
 }
 
 bool InstantLoader::IsPointerDownFromActivate() const {
   return preview_delegate_->is_pointer_down_from_activate();
 }
 
 void InstantLoader::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
 #if defined(OS_MACOSX)
   if (type == content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED) {
     if (content::RenderWidgetHostView* rwhv =
             preview_contents_->web_contents()->GetRenderWidgetHostView())
       rwhv->SetTakesFocusOnlyOnMouseDown(true);
     return;
   }
   NOTREACHED();
 #endif
 }
 
 void InstantLoader::SetupPreviewContents() {
   content::WebContents* new_contents = preview_contents_->web_contents();
+  new_contents->SetUserData(&kUserDataKey, new InstantLoaderUserData(this));
   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).
   BlockedContentTabHelper::FromWebContents(new_contents)->
       SetAllContentsBlocked(true);
   preview_contents_->constrained_window_tab_helper()->
       set_delegate(new_delegate);
@@ skipping 42 matching lines @@
                                            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(TabContents::FromWebContents(new_contents));
   SetupPreviewContents();
   loader_delegate_->SwappedTabContents(this);
 }