chrome/browser/ui/browser_instant_controller_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/basictypes.h"
   8 #include "base/memory/scoped_vector.h"
   9 #include "chrome/browser/chrome_notification_types.h"
  10 #include "chrome/browser/search/instant_service.h"
  11 #include "chrome/browser/search/instant_service_observer.h"
  12 #include "chrome/browser/search/instant_unittest_base.h"
  13 #include "chrome/browser/search/search.h"
  14 #include "chrome/browser/ui/browser_instant_controller.h"
  15 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  16 #include "chrome/common/pref_names.h"
  17 #include "chrome/common/url_constants.h"
  18 #include "content/public/browser/navigation_controller.h"
  19 #include "content/public/browser/render_process_host.h"
  20 #include "content/public/browser/web_contents.h"
  21 #include "content/public/browser/web_contents_observer.h"
  22
  23 namespace chrome {
  24
  25 namespace {
  26
  27 class BrowserInstantControllerTest : public InstantUnitTestBase {
  28  protected:
  29   friend class FakeWebContentsObserver;
  30 };
  31
  32 const struct TabReloadTestCase {
  33   const char* description;
  34   const char* start_url;
  35   bool start_in_instant_process;
  36   bool should_reload;
  37   bool end_in_instant_process;
  38 } kTabReloadTestCases[] = {
  39     {"Local Embedded NTP", chrome::kChromeSearchLocalNtpUrl,
  40      true, true, true},
  41     {"Remote Embedded NTP", "https://www.google.com/instant?strk",
  42      true, true, false},
  43     {"Remote Embedded SERP", "https://www.google.com/url?strk&bar=search+terms",
  44      true, true, false},
  45     {"Other NTP", "https://bar.com/instant?strk",
  46      false, false, false}
  47 };
  48
  49 class FakeWebContentsObserver : public content::WebContentsObserver {
  50  public:
  51   explicit FakeWebContentsObserver(content::WebContents* contents)
  52       : WebContentsObserver(contents),
  53         contents_(contents),
  54         url_(contents->GetURL()),
  55         num_reloads_(0) {}
  56
  57   virtual void DidStartNavigationToPendingEntry(
  58       const GURL& url,
  59       content::NavigationController::ReloadType reload_type) OVERRIDE {
  60     if (url_ == url)
  61       num_reloads_++;
  62   }
  63
  64   const GURL url() const {
  65     return url_;
  66   }
  67
  68   int num_reloads() const {
  69     return num_reloads_;
  70   }
  71
  72  protected:
  73   friend class BrowserInstantControllerTest;
  74   FRIEND_TEST_ALL_PREFIXES(BrowserInstantControllerTest,
  75                            DefaultSearchProviderChanged);
  76   FRIEND_TEST_ALL_PREFIXES(BrowserInstantControllerTest,
  77                            GoogleBaseURLUpdated);
  78
  79  private:
  80   content::WebContents* contents_;
  81   const GURL& url_;
  82   int num_reloads_;
  83 };
  84
  85 TEST_F(BrowserInstantControllerTest, DefaultSearchProviderChanged) {
  86   size_t num_tests = arraysize(kTabReloadTestCases);
  87   ScopedVector<FakeWebContentsObserver> observers;
  88   for (size_t i = 0; i < num_tests; ++i) {
  89     const TabReloadTestCase& test = kTabReloadTestCases[i];
  90     AddTab(browser(), GURL(test.start_url));
  91     content::WebContents* contents =
  92       browser()->tab_strip_model()->GetActiveWebContents();
  93
  94     // Validate initial instant state.
  95     EXPECT_EQ(test.start_in_instant_process,
  96         instant_service_->IsInstantProcess(
  97           contents->GetRenderProcessHost()->GetID()))
  98       << test.description;
  99
 100     // Setup an observer to verify reload or absence thereof.
 101     observers.push_back(new FakeWebContentsObserver(contents));
 102   }
 103
 104   SetDefaultSearchProvider("https://bar.com/");
 105
 106   for (size_t i = 0; i < num_tests; ++i) {
 107     FakeWebContentsObserver* observer = observers[i];
 108     const TabReloadTestCase& test = kTabReloadTestCases[i];
 109
 110     if (test.should_reload) {
 111       // Validate final instant state.
 112       EXPECT_EQ(
 113           test.end_in_instant_process,
 114           chrome::ShouldAssignURLToInstantRenderer(observer->url(), profile()))
 115         << test.description;
 116     }
 117
 118     // Ensure only the expected tabs(contents) reloaded.
 119     EXPECT_EQ(test.should_reload ? 1 : 0, observer->num_reloads())
 120       << test.description;
 121   }
 122 }
 123
 124 TEST_F(BrowserInstantControllerTest, GoogleBaseURLUpdated) {
 125   const size_t num_tests = arraysize(kTabReloadTestCases);
 126   ScopedVector<FakeWebContentsObserver> observers;
 127   for (size_t i = 0; i < num_tests; ++i) {
 128     const TabReloadTestCase& test = kTabReloadTestCases[i];
 129     AddTab(browser(), GURL(test.start_url));
 130     content::WebContents* contents =
 131       browser()->tab_strip_model()->GetActiveWebContents();
 132
 133     // Validate initial instant state.
 134     EXPECT_EQ(test.start_in_instant_process,
 135         instant_service_->IsInstantProcess(
 136           contents->GetRenderProcessHost()->GetID()))
 137       << test.description;
 138
 139     // Setup an observer to verify reload or absence thereof.
 140     observers.push_back(new FakeWebContentsObserver(contents));
 141   }
 142
 143   NotifyGoogleBaseURLUpdate("https://www.google.es/");
 144
 145   for (size_t i = 0; i < num_tests; ++i) {
 146     const TabReloadTestCase& test = kTabReloadTestCases[i];
 147     FakeWebContentsObserver* observer = observers[i];
 148
 149     if (test.should_reload) {
 150       // Validate final instant state.
 151       EXPECT_EQ(
 152           test.end_in_instant_process,
 153           chrome::ShouldAssignURLToInstantRenderer(observer->url(), profile()))
 154         << test.description;
 155     }
 156
 157     // Ensure only the expected tabs(contents) reloaded.
 158     EXPECT_EQ(test.should_reload ? 1 : 0, observer->num_reloads())
 159       << test.description;
 160   }
 161 }
 162
 163 TEST_F(BrowserInstantControllerTest, BrowserWindowLifecycle) {
 164   scoped_ptr<BrowserWindow> window(CreateBrowserWindow());
 165   Browser::CreateParams params(profile(), chrome::HOST_DESKTOP_TYPE_NATIVE);
 166   params.window = window.get();
 167   scoped_ptr<Browser> browser(new Browser(params));
 168   InstantServiceObserver* bic;
 169   bic = browser->instant_controller();
 170   EXPECT_TRUE(IsInstantServiceObserver(bic))
 171     << "New BrowserInstantController should register as InstantServiceObserver";
 172
 173   browser.reset(NULL);
 174   window.reset(NULL);
 175   EXPECT_FALSE(IsInstantServiceObserver(bic))
 176     << "New BrowserInstantController should register as InstantServiceObserver";
 177 }
 178
 179 }  // namespace
 180
 181 }  // namespace chrome