Merge InstantPage into InstantTab.

InstantPage objects are never instantiated except as InstantTab, which
is its only subclass.

BUG=627747

Review-Url: https://codereview.chromium.org/2144733004
Cr-Commit-Position: refs/heads/master@{#405223}

chrome/browser/ui/search/instant_controller.cc

@@ -31,7 +31,7 @@
 
 namespace {
 
-bool IsContentsFrom(const InstantPage* page,
+bool IsContentsFrom(const InstantTab* page,
                     const content::WebContents* contents) {
   return page && (page->web_contents() == contents);
 }
@@ -124,8 +124,8 @@ InstantTab* InstantController::instant_tab() const {
 
 void InstantController::InstantSupportChanged(
     InstantSupportState instant_support) {
-  // Handle INSTANT_SUPPORT_YES here because InstantPage is not hooked up to the
-  // active tab. Search model changed listener in InstantPage will handle other
+  // Handle INSTANT_SUPPORT_YES here because InstantTab is not hooked up to the
+  // active tab. Search model changed listener in InstantTab will handle other
   // cases.
   if (instant_support != INSTANT_SUPPORT_YES)
     return;
@@ -148,7 +148,7 @@ void InstantController::InstantSupportDetermined(
       content::NotificationService::NoDetails());
 }
 
-void InstantController::InstantPageAboutToNavigateMainFrame(
+void InstantController::InstantTabAboutToNavigateMainFrame(
     const content::WebContents* contents,
     const GURL& url) {
   DCHECK(IsContentsFrom(instant_tab(), contents));

chrome/browser/ui/search/instant_controller.h

@@ -15,13 +15,12 @@
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
-#include "chrome/browser/ui/search/instant_page.h"
+#include "chrome/browser/ui/search/instant_tab.h"
 #include "chrome/common/search/search_types.h"
 
 class BrowserInstantController;
 class GURL;
 class InstantService;
-class InstantTab;
 class Profile;
 struct EmbeddedSearchRequestParams;
 
@@ -32,13 +31,13 @@ class WebContents;
 // InstantController drives Chrome Instant, i.e., the browser implementation of
 // the Embedded Search API (see http://dev.chromium.org/embeddedsearch).
 //
-// In extended mode, InstantController maintains and coordinates an InstantTab
-// instance of InstantPage. An InstantTab instance points to the currently
-// active tab, if it supports the Embedded Search API. InstantTab is backed by a
-// WebContents and it does not own that WebContents.
+// In extended mode, InstantController maintains and coordinates an InstantTab.
+// An InstantTab instance points to the currently active tab, if it supports the
+// Embedded Search API. InstantTab is backed by a WebContents and it does not
+// own that WebContents.
 //
 // InstantController is owned by Browser via BrowserInstantController.
-class InstantController : public InstantPage::Delegate {
+class InstantController : public InstantTab::Delegate {
  public:
   explicit InstantController(BrowserInstantController* browser);
   ~InstantController() override;
@@ -104,13 +103,13 @@ class InstantController : public InstantPage::Delegate {
   FRIEND_TEST_ALL_PREFIXES(InstantExtendedTest,
                            DispatchMVChangeEventWhileNavigatingBackToNTP);
 
-  // Overridden from InstantPage::Delegate:
+  // Overridden from InstantTab::Delegate:
   // TODO(shishir): We assume that the WebContent's current RenderViewHost is
   // the RenderViewHost being created which is not always true. Fix this.
   void InstantSupportDetermined(const content::WebContents* contents,
                                 bool supports_instant) override;
-  void InstantPageAboutToNavigateMainFrame(const content::WebContents* contents,
-                                           const GURL& url) override;
+  void InstantTabAboutToNavigateMainFrame(const content::WebContents* contents,
+                                          const GURL& url) override;
 
   // If the active tab is an Instant search results page, sets |instant_tab_| to
   // point to it. Else, deletes any existing |instant_tab_|.
@@ -124,7 +123,7 @@ class InstantController : public InstantPage::Delegate {
 
   BrowserInstantController* const browser_;
 
-  // The instance of InstantPage maintained by InstantController.
+  // The instance of InstantTab maintained by InstantController.
   std::unique_ptr<InstantTab> instant_tab_;
 
   // The search model mode for the active tab.

chrome/browser/ui/search/instant_page.cc

-// Copyright 2013 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/ui/search/instant_page.h"
-
-#include "chrome/browser/ui/search/search_model.h"
-#include "chrome/browser/ui/search/search_tab_helper.h"
-#include "chrome/common/url_constants.h"
-#include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/web_contents.h"
-
-InstantPage::Delegate::~Delegate() {
-}
-
-InstantPage::~InstantPage() {
-  if (web_contents()) {
-    SearchTabHelper::FromWebContents(web_contents())->model()->RemoveObserver(
-        this);
-  }
-}
-
-bool InstantPage::supports_instant() const {
-  return web_contents() &&
-      SearchTabHelper::FromWebContents(web_contents())->SupportsInstant();
-}
-
-bool InstantPage::IsLocal() const {
-  return web_contents() &&
-      web_contents()->GetURL() == GURL(chrome::kChromeSearchLocalNtpUrl);
-}
-
-InstantPage::InstantPage(Delegate* delegate)
-    : delegate_(delegate) {
-}
-
-void InstantPage::SetContents(content::WebContents* new_web_contents) {
-  ClearContents();
-
-  if (!new_web_contents)
-    return;
-
-  Observe(new_web_contents);
-  SearchModel* model =
-      SearchTabHelper::FromWebContents(web_contents())->model();
-  model->AddObserver(this);
-
-  // Already know whether the page supports instant.
-  if (model->instant_support() != INSTANT_SUPPORT_UNKNOWN)
-    InstantSupportDetermined(model->instant_support() == INSTANT_SUPPORT_YES);
-}
-
-bool InstantPage::ShouldProcessAboutToNavigateMainFrame() {
-  return false;
-}
-
-void InstantPage::DidCommitProvisionalLoadForFrame(
-    content::RenderFrameHost* render_frame_host,
-    const GURL& url,
-    ui::PageTransition /* transition_type */) {
-  if (!render_frame_host->GetParent() &&
-      ShouldProcessAboutToNavigateMainFrame()) {
-    delegate_->InstantPageAboutToNavigateMainFrame(web_contents(), url);
-  }
-}
-
-void InstantPage::ModelChanged(const SearchModel::State& old_state,
-                               const SearchModel::State& new_state) {
-  if (old_state.instant_support != new_state.instant_support)
-    InstantSupportDetermined(new_state.instant_support == INSTANT_SUPPORT_YES);
-}
-
-void InstantPage::InstantSupportDetermined(bool supports_instant) {
-  delegate_->InstantSupportDetermined(web_contents(), supports_instant);
-
-  // If the page doesn't support Instant, stop listening to it.
-  if (!supports_instant)
-    ClearContents();
-}
-
-void InstantPage::ClearContents() {
-  if (web_contents()) {
-    SearchTabHelper::FromWebContents(web_contents())->model()->RemoveObserver(
-        this);
-  }
-
-  Observe(NULL);
-}

chrome/browser/ui/search/instant_page.h

-// Copyright 2013 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.
-
-#ifndef CHROME_BROWSER_UI_SEARCH_INSTANT_PAGE_H_
-#define CHROME_BROWSER_UI_SEARCH_INSTANT_PAGE_H_
-
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "chrome/browser/ui/search/search_model_observer.h"
-#include "content/public/browser/web_contents_observer.h"
-#include "ui/base/page_transition_types.h"
-
-class GURL;
-
-namespace content {
-class RenderFrameHost;
-class WebContents;
-}
-
-// InstantPage is used to exchange messages with a page that implements the
-// Instant/Embedded Search API (http://dev.chromium.org/embeddedsearch).
-// InstantPage is not used directly but via its derived class, InstantTab.
-class InstantPage : public content::WebContentsObserver,
-                    public SearchModelObserver {
- public:
-  // InstantPage calls its delegate in response to messages received from the
-  // page. Each method is called with the |contents| corresponding to the page
-  // we are observing.
-  class Delegate {
-   public:
-    // Called upon determination of Instant API support. Either in response to
-    // the page loading or because we received some other message.
-    virtual void InstantSupportDetermined(const content::WebContents* contents,
-                                          bool supports_instant) = 0;
-
-    // Called when the page is about to navigate to |url|.
-    virtual void InstantPageAboutToNavigateMainFrame(
-        const content::WebContents* contents,
-        const GURL& url) = 0;
-
-   protected:
-    virtual ~Delegate();
-  };
-
-  ~InstantPage() override;
-
-  // Returns true if the page is known to support the Instant API. This starts
-  // out false, and is set to true whenever we get any message from the page.
-  // Once true, it never becomes false (the page isn't expected to drop API
-  // support suddenly).
-  bool supports_instant() const;
-
-  // Returns true if the page is the local NTP (i.e. its URL is
-  // chrome::kChromeSearchLocalNTPURL).
-  bool IsLocal() const;
-
- protected:
-  explicit InstantPage(Delegate* delegate);
-
-  // Sets |web_contents| as the page to communicate with. |web_contents| may be
-  // NULL, which effectively stops all communication.
-  void SetContents(content::WebContents* web_contents);
-
-  Delegate* delegate() const { return delegate_; }
-
-  // This method is called before processing messages received from the page.
-  virtual bool ShouldProcessAboutToNavigateMainFrame();
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest, IsLocal);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest,
-                           DetermineIfPageSupportsInstant_Local);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest,
-                           DetermineIfPageSupportsInstant_NonLocal);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest,
-                           PageURLDoesntBelongToInstantRenderer);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest, PageSupportsInstant);
-
-  // Overridden from content::WebContentsObserver:
-  void DidCommitProvisionalLoadForFrame(
-      content::RenderFrameHost* render_frame_host,
-      const GURL& url,
-      ui::PageTransition transition_type) override;
-
-  // Overridden from SearchModelObserver:
-  void ModelChanged(const SearchModel::State& old_state,
-                    const SearchModel::State& new_state) override;
-
-  // Update the status of Instant support.
-  void InstantSupportDetermined(bool supports_instant);
-
-  void ClearContents();
-
-  Delegate* const delegate_;
-
-  DISALLOW_COPY_AND_ASSIGN(InstantPage);
-};
-
-#endif  // CHROME_BROWSER_UI_SEARCH_INSTANT_PAGE_H_

chrome/browser/ui/search/instant_tab.cc

-// Copyright 2012 The Chromium Authors. All rights reserved.
+// Copyright 2013 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/ui/search/instant_tab.h"
 
-#include "chrome/browser/ui/webui/ntp/ntp_user_data_logger.h"
+#include "chrome/browser/ui/search/search_model.h"
+#include "chrome/browser/ui/search/search_tab_helper.h"
+#include "chrome/common/url_constants.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 
-InstantTab::InstantTab(InstantPage::Delegate* delegate)
-    : InstantPage(delegate) {
+InstantTab::Delegate::~Delegate() {
 }
 
 InstantTab::~InstantTab() {
+  if (web_contents()) {
+    SearchTabHelper::FromWebContents(web_contents())->model()->RemoveObserver(
+        this);
+  }
 }
 
-void InstantTab::Init(content::WebContents* contents) {
-  SetContents(contents);
+bool InstantTab::supports_instant() const {
+  return web_contents() &&
+      SearchTabHelper::FromWebContents(web_contents())->SupportsInstant();
 }
 
-bool InstantTab::ShouldProcessAboutToNavigateMainFrame() {
-  return true;
+bool InstantTab::IsLocal() const {
+  return web_contents() &&
+      web_contents()->GetURL() == GURL(chrome::kChromeSearchLocalNtpUrl);
+}
+
+InstantTab::InstantTab(Delegate* delegate)
+    : delegate_(delegate) {
+}
+
+void InstantTab::Init(content::WebContents* new_web_contents) {
+  ClearContents();
+
+  if (!new_web_contents)
+    return;
+
+  Observe(new_web_contents);
+  SearchModel* model =
+      SearchTabHelper::FromWebContents(web_contents())->model();
+  model->AddObserver(this);
+
+  // Already know whether the page supports instant.
+  if (model->instant_support() != INSTANT_SUPPORT_UNKNOWN)
+    InstantSupportDetermined(model->instant_support() == INSTANT_SUPPORT_YES);
+}
+
+void InstantTab::DidCommitProvisionalLoadForFrame(
+    content::RenderFrameHost* render_frame_host,
+    const GURL& url,
+    ui::PageTransition /* transition_type */) {
+  if (!render_frame_host->GetParent()) {
+    delegate_->InstantTabAboutToNavigateMainFrame(web_contents(), url);
+  }
+}
+
+void InstantTab::ModelChanged(const SearchModel::State& old_state,
+                               const SearchModel::State& new_state) {
+  if (old_state.instant_support != new_state.instant_support)
+    InstantSupportDetermined(new_state.instant_support == INSTANT_SUPPORT_YES);
+}
+
+void InstantTab::InstantSupportDetermined(bool supports_instant) {
+  delegate_->InstantSupportDetermined(web_contents(), supports_instant);
+
+  // If the page doesn't support Instant, stop listening to it.
+  if (!supports_instant)
+    ClearContents();
+}
+
+void InstantTab::ClearContents() {
+  if (web_contents()) {
+    SearchTabHelper::FromWebContents(web_contents())->model()->RemoveObserver(
+        this);
+  }
+
+  Observe(NULL);
 }

chrome/browser/ui/search/instant_tab.h

-// Copyright 2012 The Chromium Authors. All rights reserved.
+// Copyright 2013 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.
 
@@ -6,23 +6,87 @@
 #define CHROME_BROWSER_UI_SEARCH_INSTANT_TAB_H_
 
 #include "base/compiler_specific.h"
+#include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "chrome/browser/ui/search/instant_page.h"
+#include "chrome/browser/ui/search/search_model_observer.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "ui/base/page_transition_types.h"
 
-// InstantTab represents a committed page (i.e. an actual tab on the tab strip)
-// that supports the Instant API.
-class InstantTab : public InstantPage {
+class GURL;
+
+namespace content {
+class RenderFrameHost;
+class WebContents;
+}
+
+// InstantTab is used to exchange messages with a page that implements the
+// Instant/Embedded Search API (http://dev.chromium.org/embeddedsearch).
+class InstantTab : public content::WebContentsObserver,
+                    public SearchModelObserver {
  public:
-  explicit InstantTab(InstantPage::Delegate* delegate);
+  // InstantTab calls its delegate in response to messages received from the
+  // page. Each method is called with the |contents| corresponding to the page
+  // we are observing.
+  class Delegate {
+   public:
+    // Called upon determination of Instant API support. Either in response to
+    // the page loading or because we received some other message.
+    virtual void InstantSupportDetermined(const content::WebContents* contents,
+                                          bool supports_instant) = 0;
+
+    // Called when the page is about to navigate to |url|.
+    virtual void InstantTabAboutToNavigateMainFrame(
+        const content::WebContents* contents,
+        const GURL& url) = 0;
+
+   protected:
+    virtual ~Delegate();
+  };
+
+  explicit InstantTab(Delegate* delegate);
+
   ~InstantTab() override;
 
-  // Start observing |contents| for messages. Sends a message to determine if
-  // the page supports the Instant API.
-  void Init(content::WebContents* contents);
+  // Sets |web_contents| as the page to communicate with. |web_contents| may be
+  // NULL, which effectively stops all communication.
+  void Init(content::WebContents* web_contents);
+
+  // Returns true if the page is known to support the Instant API. This starts
+  // out false, and is set to true whenever we get any message from the page.
+  // Once true, it never becomes false (the page isn't expected to drop API
+  // support suddenly).
+  bool supports_instant() const;
+
+  // Returns true if the page is the local NTP (i.e. its URL is
+  // chrome::kChromeSearchLocalNTPURL).
+  bool IsLocal() const;
 
  private:
-  // Overridden from InstantPage:
-  bool ShouldProcessAboutToNavigateMainFrame() override;
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest, IsLocal);
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest,
+                           DetermineIfPageSupportsInstant_Local);
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest,
+                           DetermineIfPageSupportsInstant_NonLocal);
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest,
+                           PageURLDoesntBelongToInstantRenderer);
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest, PageSupportsInstant);
+
+  // Overridden from content::WebContentsObserver:
+  void DidCommitProvisionalLoadForFrame(
+      content::RenderFrameHost* render_frame_host,
+      const GURL& url,
+      ui::PageTransition transition_type) override;
+
+  // Overridden from SearchModelObserver:
+  void ModelChanged(const SearchModel::State& old_state,
+                    const SearchModel::State& new_state) override;
+
+  // Update the status of Instant support.
+  void InstantSupportDetermined(bool supports_instant);
+
+  void ClearContents();
+
+  Delegate* const delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantTab);
 };

chrome/browser/ui/search/instant_page_unittest.cc → chrome/browser/ui/search/instant_tab_unittest.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/ui/search/instant_page.h"
+#include "chrome/browser/ui/search/instant_tab.h"
 
 #include <stdint.h>
 
@@ -27,7 +27,7 @@ class Profile;
 
 namespace {
 
-class FakePageDelegate : public InstantPage::Delegate {
+class FakePageDelegate : public InstantTab::Delegate {
  public:
   virtual ~FakePageDelegate() {
   }
@@ -35,9 +35,9 @@ class FakePageDelegate : public InstantPage::Delegate {
   MOCK_METHOD2(InstantSupportDetermined,
                void(const content::WebContents* contents,
                     bool supports_instant));
-  MOCK_METHOD1(InstantPageRenderProcessGone,
+  MOCK_METHOD1(InstantTabRenderProcessGone,
                void(const content::WebContents* contents));
-  MOCK_METHOD2(InstantPageAboutToNavigateMainFrame,
+  MOCK_METHOD2(InstantTabAboutToNavigateMainFrame,
                void(const content::WebContents* contents,
                     const GURL& url));
   MOCK_METHOD5(NavigateToURL,
@@ -50,7 +50,7 @@ class FakePageDelegate : public InstantPage::Delegate {
 
 }  // namespace
 
-class InstantPageTest : public ChromeRenderViewHostTestHarness {
+class InstantTabTest : public ChromeRenderViewHostTestHarness {
  public:
   void SetUp() override;
 
@@ -58,30 +58,30 @@ class InstantPageTest : public ChromeRenderViewHostTestHarness {
     return process()->sink().GetFirstMessageMatching(id) != NULL;
   }
 
-  std::unique_ptr<InstantPage> page;
+  std::unique_ptr<InstantTab> page;
   FakePageDelegate delegate;
 };
 
-void InstantPageTest::SetUp() {
+void InstantTabTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
   SearchTabHelper::CreateForWebContents(web_contents());
 }
 
-TEST_F(InstantPageTest, IsLocal) {
-  page.reset(new InstantPage(&delegate));
+TEST_F(InstantTabTest, IsLocal) {
+  page.reset(new InstantTab(&delegate));
   EXPECT_FALSE(page->supports_instant());
   EXPECT_FALSE(page->IsLocal());
-  page->SetContents(web_contents());
+  page->Init(web_contents());
   NavigateAndCommit(GURL(chrome::kChromeSearchLocalNtpUrl));
   EXPECT_TRUE(page->IsLocal());
   NavigateAndCommit(GURL("http://example.com"));
   EXPECT_FALSE(page->IsLocal());
 }
 
-TEST_F(InstantPageTest, DetermineIfPageSupportsInstant_Local) {
-  page.reset(new InstantPage(&delegate));
+TEST_F(InstantTabTest, DetermineIfPageSupportsInstant_Local) {
+  page.reset(new InstantTab(&delegate));
   EXPECT_FALSE(page->supports_instant());
-  page->SetContents(web_contents());
+  page->Init(web_contents());
   NavigateAndCommit(GURL(chrome::kChromeSearchLocalNtpUrl));
   EXPECT_TRUE(page->IsLocal());
   EXPECT_CALL(delegate, InstantSupportDetermined(web_contents(), true))
@@ -91,10 +91,10 @@ TEST_F(InstantPageTest, DetermineIfPageSupportsInstant_Local) {
   EXPECT_TRUE(page->supports_instant());
 }
 
-TEST_F(InstantPageTest, DetermineIfPageSupportsInstant_NonLocal) {
-  page.reset(new InstantPage(&delegate));
+TEST_F(InstantTabTest, DetermineIfPageSupportsInstant_NonLocal) {
+  page.reset(new InstantTab(&delegate));
   EXPECT_FALSE(page->supports_instant());
-  page->SetContents(web_contents());
+  page->Init(web_contents());
   NavigateAndCommit(GURL("chrome-search://foo/bar"));
   EXPECT_FALSE(page->IsLocal());
   process()->sink().ClearMessages();
@@ -106,11 +106,11 @@ TEST_F(InstantPageTest, DetermineIfPageSupportsInstant_NonLocal) {
   EXPECT_EQ(web_contents()->GetRoutingID(), message->routing_id());
 }
 
-TEST_F(InstantPageTest, PageURLDoesntBelongToInstantRenderer) {
-  page.reset(new InstantPage(&delegate));
+TEST_F(InstantTabTest, PageURLDoesntBelongToInstantRenderer) {
+  page.reset(new InstantTab(&delegate));
   EXPECT_FALSE(page->supports_instant());
   NavigateAndCommit(GURL(chrome::kChromeSearchLocalNtpUrl));
-  page->SetContents(web_contents());
+  page->Init(web_contents());
 
   // Navigate to a page URL that doesn't belong to Instant renderer.
   // SearchTabHelper::DeterminerIfPageSupportsInstant() should return
@@ -130,11 +130,11 @@ TEST_F(InstantPageTest, PageURLDoesntBelongToInstantRenderer) {
 }
 
 // Test to verify that ChromeViewMsg_DetermineIfPageSupportsInstant message
-// reply handler updates the instant support state in InstantPage.
-TEST_F(InstantPageTest, PageSupportsInstant) {
-  page.reset(new InstantPage(&delegate));
+// reply handler updates the instant support state in InstantTab.
+TEST_F(InstantTabTest, PageSupportsInstant) {
+  page.reset(new InstantTab(&delegate));
   EXPECT_FALSE(page->supports_instant());
-  page->SetContents(web_contents());
+  page->Init(web_contents());
   NavigateAndCommit(GURL("chrome-search://foo/bar"));
   process()->sink().ClearMessages();
   SearchTabHelper::FromWebContents(web_contents())->
@@ -148,7 +148,7 @@ TEST_F(InstantPageTest, PageSupportsInstant) {
       .Times(1);
 
   // Assume the page supports instant. Invoke the message reply handler to make
-  // sure the InstantPage is notified about the instant support state.
+  // sure the InstantTab is notified about the instant support state.
   const content::NavigationEntry* entry =
       web_contents()->GetController().GetLastCommittedEntry();
   EXPECT_TRUE(entry);

chrome/browser/ui/search/search_tab_helper.h

@@ -27,8 +27,8 @@ struct LoadCommittedDetails;
 }
 
 class GURL;
-class InstantPageTest;
 class InstantService;
+class InstantTabTest;
 class OmniboxView;
 class Profile;
 class SearchIPCRouterTest;
@@ -97,7 +97,7 @@ class SearchTabHelper : public content::WebContentsObserver,
 
  private:
   friend class content::WebContentsUserData<SearchTabHelper>;
-  friend class InstantPageTest;
+  friend class InstantTabTest;
   friend class SearchIPCRouterPolicyTest;
   friend class SearchIPCRouterTest;
   friend class SearchTabHelperPrerenderTest;
@@ -134,13 +134,13 @@ class SearchTabHelper : public content::WebContentsObserver,
   FRIEND_TEST_ALL_PREFIXES(SearchIPCRouterTest,
                            DoNotSendSetDisplayInstantResultsMsg);
   FRIEND_TEST_ALL_PREFIXES(SearchIPCRouterTest, HandleTabChangedEvents);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest,
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest,
                            DetermineIfPageSupportsInstant_Local);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest,
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest,
                            DetermineIfPageSupportsInstant_NonLocal);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest,
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest,
                            PageURLDoesntBelongToInstantRenderer);
-  FRIEND_TEST_ALL_PREFIXES(InstantPageTest, PageSupportsInstant);
+  FRIEND_TEST_ALL_PREFIXES(InstantTabTest, PageSupportsInstant);
 
   explicit SearchTabHelper(content::WebContents* web_contents);
 

chrome/chrome_browser_ui.gypi

@@ -112,8 +112,6 @@
       'browser/ui/protocol_dialog_delegate.h',
       'browser/ui/proximity_auth/proximity_auth_error_bubble.h',
       'browser/ui/screen_capture_notification_ui.h',
-      'browser/ui/search/instant_page.cc',
-      'browser/ui/search/instant_page.h',
       'browser/ui/search/instant_search_prerenderer.cc',
       'browser/ui/search/instant_search_prerenderer.h',
       'browser/ui/search/instant_tab.cc',

chrome/chrome_tests_unit.gypi

@@ -1537,8 +1537,8 @@
       'browser/ui/passwords/manage_passwords_bubble_model_unittest.cc',
       'browser/ui/passwords/manage_passwords_view_utils_desktop_unittest.cc',
       'browser/ui/passwords/password_dialog_controller_impl_unittest.cc',
-      'browser/ui/search/instant_page_unittest.cc',
       'browser/ui/search/instant_search_prerenderer_unittest.cc',
+      'browser/ui/search/instant_tab_unittest.cc',
       'browser/ui/search/search_delegate_unittest.cc',
       'browser/ui/search/search_ipc_router_policy_unittest.cc',
       'browser/ui/search/search_ipc_router_unittest.cc',