chrome/browser/chrome_content_browser_client_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 "chrome/browser/chrome_content_browser_client.h"
   6
   7 #include <map>
   8
   9 #include "base/command_line.h"
  10 #include "base/metrics/field_trial.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/search_engines/template_url_service_factory.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  15 #include "chrome/test/base/browser_with_test_window_test.h"
  16 #include "chrome/test/base/ui_test_utils.h"
  17 #include "components/content_settings/core/browser/host_content_settings_map.h"
  18 #include "components/search_engines/template_url_service.h"
  19 #include "components/variations/entropy_provider.h"
  20 #include "components/variations/variations_associated_data.h"
  21 #include "components/version_info/version_info.h"
  22 #include "content/public/browser/navigation_controller.h"
  23 #include "content/public/browser/navigation_entry.h"
  24 #include "content/public/browser/web_contents.h"
  25 #include "content/public/common/content_switches.h"
  26 #include "content/public/test/test_browser_thread_bundle.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28 #include "url/gurl.h"
  29
  30 namespace chrome {
  31
  32 using ChromeContentBrowserClientTest = testing::Test;
  33
  34 TEST_F(ChromeContentBrowserClientTest, ShouldAssignSiteForURL) {
  35   ChromeContentBrowserClient client;
  36   EXPECT_FALSE(client.ShouldAssignSiteForURL(GURL("chrome-native://test")));
  37   EXPECT_TRUE(client.ShouldAssignSiteForURL(GURL("http://www.google.com")));
  38   EXPECT_TRUE(client.ShouldAssignSiteForURL(GURL("https://www.google.com")));
  39 }
  40
  41 // BrowserWithTestWindowTest doesn't work on iOS and Android.
  42 #if !defined(OS_ANDROID) && !defined(OS_IOS)
  43
  44 using ChromeContentBrowserClientWindowTest = BrowserWithTestWindowTest;
  45
  46 static void DidOpenURLForWindowTest(content::WebContents** target_contents,
  47                                     content::WebContents* opened_contents) {
  48   DCHECK(target_contents);
  49
  50   *target_contents = opened_contents;
  51 }
  52
  53 // This test opens two URLs using ContentBrowserClient::OpenURL. It expects the
  54 // URLs to be opened in new tabs and activated, changing the active tabs after
  55 // each call and increasing the tab count by 2.
  56 TEST_F(ChromeContentBrowserClientWindowTest, OpenURL) {
  57   ChromeContentBrowserClient client;
  58
  59   int previous_count = browser()->tab_strip_model()->count();
  60
  61   GURL urls[] = { GURL("https://www.google.com"),
  62                   GURL("https://www.chromium.org") };
  63
  64   for (const GURL& url : urls) {
  65     content::OpenURLParams params(url,
  66                                   content::Referrer(),
  67                                   NEW_FOREGROUND_TAB,
  68                                   ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
  69                                   false);
  70     // TODO(peter): We should have more in-depth browser tests for the window
  71     // opening functionality, which also covers Android. This test can currently
  72     // only be ran on platforms where OpenURL is implemented synchronously.
  73     // See https://crbug.com/457667.
  74     content::WebContents* web_contents = nullptr;
  75     client.OpenURL(browser()->profile(),
  76                    params,
  77                    base::Bind(&DidOpenURLForWindowTest, &web_contents));
  78
  79     EXPECT_TRUE(web_contents);
  80
  81     content::WebContents* active_contents = browser()->tab_strip_model()->
  82         GetActiveWebContents();
  83     EXPECT_EQ(web_contents, active_contents);
  84     EXPECT_EQ(url, active_contents->GetVisibleURL());
  85   }
  86
  87   EXPECT_EQ(previous_count + 2, browser()->tab_strip_model()->count());
  88 }
  89
  90 #endif // !defined(OS_ANDROID) && !defined(OS_IOS)
  91
  92 #if defined(ENABLE_WEBRTC)
  93
  94 // NOTE: Any updates to the expectations in these tests should also be done in
  95 // the browser test WebRtcDisableEncryptionFlagBrowserTest.
  96 class DisableWebRtcEncryptionFlagTest : public testing::Test {
  97  public:
  98   DisableWebRtcEncryptionFlagTest()
  99       : from_command_line_(base::CommandLine::NO_PROGRAM),
 100         to_command_line_(base::CommandLine::NO_PROGRAM) {}
 101
 102  protected:
 103   void SetUp() override {
 104     from_command_line_.AppendSwitch(switches::kDisableWebRtcEncryption);
 105   }
 106
 107   void MaybeCopyDisableWebRtcEncryptionSwitch(version_info::Channel channel) {
 108     ChromeContentBrowserClient::MaybeCopyDisableWebRtcEncryptionSwitch(
 109         &to_command_line_,
 110         from_command_line_,
 111         channel);
 112   }
 113
 114   base::CommandLine from_command_line_;
 115   base::CommandLine to_command_line_;
 116
 117   DISALLOW_COPY_AND_ASSIGN(DisableWebRtcEncryptionFlagTest);
 118 };
 119
 120 TEST_F(DisableWebRtcEncryptionFlagTest, UnknownChannel) {
 121   MaybeCopyDisableWebRtcEncryptionSwitch(version_info::Channel::UNKNOWN);
 122   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 123 }
 124
 125 TEST_F(DisableWebRtcEncryptionFlagTest, CanaryChannel) {
 126   MaybeCopyDisableWebRtcEncryptionSwitch(version_info::Channel::CANARY);
 127   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 128 }
 129
 130 TEST_F(DisableWebRtcEncryptionFlagTest, DevChannel) {
 131   MaybeCopyDisableWebRtcEncryptionSwitch(version_info::Channel::DEV);
 132   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 133 }
 134
 135 TEST_F(DisableWebRtcEncryptionFlagTest, BetaChannel) {
 136   MaybeCopyDisableWebRtcEncryptionSwitch(version_info::Channel::BETA);
 137 #if defined(OS_ANDROID)
 138   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 139 #else
 140   EXPECT_FALSE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 141 #endif
 142 }
 143
 144 TEST_F(DisableWebRtcEncryptionFlagTest, StableChannel) {
 145   MaybeCopyDisableWebRtcEncryptionSwitch(version_info::Channel::STABLE);
 146   EXPECT_FALSE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 147 }
 148
 149 #endif  // ENABLE_WEBRTC
 150
 151 class BlinkSettingsFieldTrialTest : public testing::Test {
 152  public:
 153   static const char kParserFieldTrialName[];
 154   static const char kIFrameFieldTrialName[];
 155
 156   BlinkSettingsFieldTrialTest()
 157       : trial_list_(NULL),
 158         command_line_(base::CommandLine::NO_PROGRAM) {}
 159
 160   void SetUp() override {
 161     command_line_.AppendSwitchASCII(
 162         switches::kProcessType, switches::kRendererProcess);
 163   }
 164
 165   void TearDown() override {
 166     variations::testing::ClearAllVariationParams();
 167   }
 168
 169   void CreateFieldTrial(const char* trial_name) {
 170     base::FieldTrialList::CreateFieldTrial(trial_name, kGroupName);
 171   }
 172
 173   void CreateFieldTrialWithParams(
 174       const char* trial_name,
 175       const char* key1, const char* value1,
 176       const char* key2, const char* value2) {
 177     std::map<std::string, std::string> params;
 178     params.insert(std::make_pair(key1, value1));
 179     params.insert(std::make_pair(key2, value2));
 180     CreateFieldTrial(trial_name);
 181     variations::AssociateVariationParams(trial_name, kGroupName, params);
 182   }
 183
 184   void AppendContentBrowserClientSwitches() {
 185     client_.AppendExtraCommandLineSwitches(&command_line_, kFakeChildProcessId);
 186   }
 187
 188   const base::CommandLine& command_line() const {
 189     return command_line_;
 190   }
 191
 192   void AppendBlinkSettingsSwitch(const char* value) {
 193     command_line_.AppendSwitchASCII(switches::kBlinkSettings, value);
 194   }
 195
 196  private:
 197   static const int kFakeChildProcessId = 1;
 198   static const char kGroupName[];
 199
 200   ChromeContentBrowserClient client_;
 201   base::FieldTrialList trial_list_;
 202   base::CommandLine command_line_;
 203
 204   content::TestBrowserThreadBundle thread_bundle_;
 205 };
 206
 207 const char BlinkSettingsFieldTrialTest::kParserFieldTrialName[] =
 208     "BackgroundHtmlParserTokenLimits";
 209 const char BlinkSettingsFieldTrialTest::kIFrameFieldTrialName[] =
 210     "LowPriorityIFrames";
 211 const char BlinkSettingsFieldTrialTest::kGroupName[] = "FakeGroup";
 212
 213 TEST_F(BlinkSettingsFieldTrialTest, NoFieldTrial) {
 214   AppendContentBrowserClientSwitches();
 215   EXPECT_FALSE(command_line().HasSwitch(switches::kBlinkSettings));
 216 }
 217
 218 TEST_F(BlinkSettingsFieldTrialTest, FieldTrialWithoutParams) {
 219   CreateFieldTrial(kParserFieldTrialName);
 220   AppendContentBrowserClientSwitches();
 221   EXPECT_FALSE(command_line().HasSwitch(switches::kBlinkSettings));
 222 }
 223
 224 TEST_F(BlinkSettingsFieldTrialTest, BlinkSettingsSwitchAlreadySpecified) {
 225   AppendBlinkSettingsSwitch("foo");
 226   CreateFieldTrialWithParams(kParserFieldTrialName,
 227                              "key1", "value1", "key2", "value2");
 228   AppendContentBrowserClientSwitches();
 229   EXPECT_TRUE(command_line().HasSwitch(switches::kBlinkSettings));
 230   EXPECT_EQ("foo",
 231             command_line().GetSwitchValueASCII(switches::kBlinkSettings));
 232 }
 233
 234 TEST_F(BlinkSettingsFieldTrialTest, FieldTrialEnabled) {
 235   CreateFieldTrialWithParams(kParserFieldTrialName,
 236                              "key1", "value1", "key2", "value2");
 237   AppendContentBrowserClientSwitches();
 238   EXPECT_TRUE(command_line().HasSwitch(switches::kBlinkSettings));
 239   EXPECT_EQ("key1=value1,key2=value2",
 240             command_line().GetSwitchValueASCII(switches::kBlinkSettings));
 241 }
 242
 243 TEST_F(BlinkSettingsFieldTrialTest, MultipleFieldTrialsEnabled) {
 244   CreateFieldTrialWithParams(kParserFieldTrialName,
 245                              "key1", "value1", "key2", "value2");
 246   CreateFieldTrialWithParams(kIFrameFieldTrialName,
 247                              "keyA", "valueA", "keyB", "valueB");
 248   AppendContentBrowserClientSwitches();
 249   EXPECT_TRUE(command_line().HasSwitch(switches::kBlinkSettings));
 250   EXPECT_EQ("key1=value1,key2=value2,keyA=valueA,keyB=valueB",
 251             command_line().GetSwitchValueASCII(switches::kBlinkSettings));
 252 }
 253
 254 TEST_F(BlinkSettingsFieldTrialTest, MultipleFieldTrialsDuplicateKeys) {
 255   CreateFieldTrialWithParams(kParserFieldTrialName,
 256                              "key1", "value1", "key2", "value2");
 257   CreateFieldTrialWithParams(kIFrameFieldTrialName,
 258                              "key2", "duplicate", "key3", "value3");
 259   AppendContentBrowserClientSwitches();
 260   EXPECT_TRUE(command_line().HasSwitch(switches::kBlinkSettings));
 261   EXPECT_EQ("key1=value1,key2=value2,key2=duplicate,key3=value3",
 262             command_line().GetSwitchValueASCII(switches::kBlinkSettings));
 263 }
 264
 265 }  // namespace chrome
 266
 267 #if !defined(OS_IOS) && !defined(OS_ANDROID)
 268 namespace content {
 269
 270 class InstantNTPURLRewriteTest : public BrowserWithTestWindowTest {
 271  protected:
 272   void SetUp() override {
 273     BrowserWithTestWindowTest::SetUp();
 274     field_trial_list_.reset(new base::FieldTrialList(
 275         new metrics::SHA1EntropyProvider("42")));
 276   }
 277
 278   void InstallTemplateURLWithNewTabPage(GURL new_tab_page_url) {
 279     TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
 280         profile(), &TemplateURLServiceFactory::BuildInstanceFor);
 281     TemplateURLService* template_url_service =
 282         TemplateURLServiceFactory::GetForProfile(browser()->profile());
 283     ui_test_utils::WaitForTemplateURLServiceToLoad(template_url_service);
 284
 285     TemplateURLData data;
 286     data.SetShortName(base::ASCIIToUTF16("foo.com"));
 287     data.SetURL("http://foo.com/url?bar={searchTerms}");
 288     data.new_tab_url = new_tab_page_url.spec();
 289     TemplateURL* template_url = new TemplateURL(data);
 290     // Takes ownership.
 291     template_url_service->Add(template_url);
 292     template_url_service->SetUserSelectedDefaultSearchProvider(template_url);
 293   }
 294
 295   scoped_ptr<base::FieldTrialList> field_trial_list_;
 296 };
 297
 298 TEST_F(InstantNTPURLRewriteTest, UberURLHandler_InstantExtendedNewTabPage) {
 299   const GURL url_original("chrome://newtab");
 300   const GURL url_rewritten("https://www.example.com/newtab");
 301   InstallTemplateURLWithNewTabPage(url_rewritten);
 302   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("InstantExtended",
 303       "Group1 use_cacheable_ntp:1"));
 304
 305   AddTab(browser(), GURL("chrome://blank"));
 306   NavigateAndCommitActiveTab(url_original);
 307
 308   NavigationEntry* entry = browser()->tab_strip_model()->
 309       GetActiveWebContents()->GetController().GetLastCommittedEntry();
 310   ASSERT_TRUE(entry != NULL);
 311   EXPECT_EQ(url_rewritten, entry->GetURL());
 312   EXPECT_EQ(url_original, entry->GetVirtualURL());
 313 }
 314
 315 }  // namespace content
 316 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID)