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 "base/command_line.h"
   8 #include "base/metrics/field_trial.h"
   9 #include "chrome/browser/search_engines/template_url_service_factory.h"
  10 #include "chrome/browser/ui/browser.h"
  11 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  12 #include "chrome/test/base/browser_with_test_window_test.h"
  13 #include "chrome/test/base/ui_test_utils.h"
  14 #include "components/content_settings/core/browser/host_content_settings_map.h"
  15 #include "components/search_engines/template_url_service.h"
  16 #include "components/variations/entropy_provider.h"
  17 #include "content/public/browser/navigation_controller.h"
  18 #include "content/public/browser/navigation_entry.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/common/content_switches.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22 #include "url/gurl.h"
  23
  24 namespace chrome {
  25
  26 using ChromeContentBrowserClientTest = testing::Test;
  27
  28 TEST_F(ChromeContentBrowserClientTest, ShouldAssignSiteForURL) {
  29   ChromeContentBrowserClient client;
  30   EXPECT_FALSE(client.ShouldAssignSiteForURL(GURL("chrome-native://test")));
  31   EXPECT_TRUE(client.ShouldAssignSiteForURL(GURL("http://www.google.com")));
  32   EXPECT_TRUE(client.ShouldAssignSiteForURL(GURL("https://www.google.com")));
  33 }
  34
  35 // BrowserWithTestWindowTest doesn't work on iOS and Android.
  36 #if !defined(OS_ANDROID) && !defined(OS_IOS)
  37
  38 using ChromeContentBrowserClientWindowTest = BrowserWithTestWindowTest;
  39
  40 static void DidOpenURLForWindowTest(content::WebContents** target_contents,
  41                                     content::WebContents* opened_contents) {
  42   DCHECK(target_contents);
  43
  44   *target_contents = opened_contents;
  45 }
  46
  47 // This test opens two URLs using ContentBrowserClient::OpenURL. It expects the
  48 // URLs to be opened in new tabs and activated, changing the active tabs after
  49 // each call and increasing the tab count by 2.
  50 TEST_F(ChromeContentBrowserClientWindowTest, OpenURL) {
  51   ChromeContentBrowserClient client;
  52
  53   int previous_count = browser()->tab_strip_model()->count();
  54
  55   GURL urls[] = { GURL("https://www.google.com"),
  56                   GURL("https://www.chromium.org") };
  57
  58   for (const GURL& url : urls) {
  59     content::OpenURLParams params(url,
  60                                   content::Referrer(),
  61                                   NEW_FOREGROUND_TAB,
  62                                   ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
  63                                   false);
  64     // TODO(peter): We should have more in-depth browser tests for the window
  65     // opening functionality, which also covers Android. This test can currently
  66     // only be ran on platforms where OpenURL is implemented synchronously.
  67     // See https://crbug.com/457667.
  68     content::WebContents* web_contents = nullptr;
  69     client.OpenURL(browser()->profile(),
  70                    params,
  71                    base::Bind(&DidOpenURLForWindowTest, &web_contents));
  72
  73     EXPECT_TRUE(web_contents);
  74
  75     content::WebContents* active_contents = browser()->tab_strip_model()->
  76         GetActiveWebContents();
  77     EXPECT_EQ(web_contents, active_contents);
  78     EXPECT_EQ(url, active_contents->GetVisibleURL());
  79   }
  80
  81   EXPECT_EQ(previous_count + 2, browser()->tab_strip_model()->count());
  82 }
  83
  84 #endif // !defined(OS_ANDROID) && !defined(OS_IOS)
  85
  86 #if defined(ENABLE_WEBRTC)
  87
  88 // NOTE: Any updates to the expectations in these tests should also be done in
  89 // the browser test WebRtcDisableEncryptionFlagBrowserTest.
  90 class DisableWebRtcEncryptionFlagTest : public testing::Test {
  91  public:
  92   DisableWebRtcEncryptionFlagTest()
  93       : from_command_line_(base::CommandLine::NO_PROGRAM),
  94         to_command_line_(base::CommandLine::NO_PROGRAM) {}
  95
  96  protected:
  97   void SetUp() override {
  98     from_command_line_.AppendSwitch(switches::kDisableWebRtcEncryption);
  99   }
 100
 101   void MaybeCopyDisableWebRtcEncryptionSwitch(VersionInfo::Channel channel) {
 102     ChromeContentBrowserClient::MaybeCopyDisableWebRtcEncryptionSwitch(
 103         &to_command_line_,
 104         from_command_line_,
 105         channel);
 106   }
 107
 108   base::CommandLine from_command_line_;
 109   base::CommandLine to_command_line_;
 110
 111   DISALLOW_COPY_AND_ASSIGN(DisableWebRtcEncryptionFlagTest);
 112 };
 113
 114 TEST_F(DisableWebRtcEncryptionFlagTest, UnknownChannel) {
 115   MaybeCopyDisableWebRtcEncryptionSwitch(VersionInfo::CHANNEL_UNKNOWN);
 116   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 117 }
 118
 119 TEST_F(DisableWebRtcEncryptionFlagTest, CanaryChannel) {
 120   MaybeCopyDisableWebRtcEncryptionSwitch(VersionInfo::CHANNEL_CANARY);
 121   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 122 }
 123
 124 TEST_F(DisableWebRtcEncryptionFlagTest, DevChannel) {
 125   MaybeCopyDisableWebRtcEncryptionSwitch(VersionInfo::CHANNEL_DEV);
 126   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 127 }
 128
 129 TEST_F(DisableWebRtcEncryptionFlagTest, BetaChannel) {
 130   MaybeCopyDisableWebRtcEncryptionSwitch(VersionInfo::CHANNEL_BETA);
 131 #if defined(OS_ANDROID)
 132   EXPECT_TRUE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 133 #else
 134   EXPECT_FALSE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 135 #endif
 136 }
 137
 138 TEST_F(DisableWebRtcEncryptionFlagTest, StableChannel) {
 139   MaybeCopyDisableWebRtcEncryptionSwitch(VersionInfo::CHANNEL_STABLE);
 140   EXPECT_FALSE(to_command_line_.HasSwitch(switches::kDisableWebRtcEncryption));
 141 }
 142
 143 #endif  // ENABLE_WEBRTC
 144
 145 }  // namespace chrome
 146
 147 #if !defined(OS_IOS) && !defined(OS_ANDROID)
 148 namespace content {
 149
 150 class InstantNTPURLRewriteTest : public BrowserWithTestWindowTest {
 151  protected:
 152   void SetUp() override {
 153     BrowserWithTestWindowTest::SetUp();
 154     field_trial_list_.reset(new base::FieldTrialList(
 155         new metrics::SHA1EntropyProvider("42")));
 156   }
 157
 158   void InstallTemplateURLWithNewTabPage(GURL new_tab_page_url) {
 159     TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
 160         profile(), &TemplateURLServiceFactory::BuildInstanceFor);
 161     TemplateURLService* template_url_service =
 162         TemplateURLServiceFactory::GetForProfile(browser()->profile());
 163     ui_test_utils::WaitForTemplateURLServiceToLoad(template_url_service);
 164
 165     TemplateURLData data;
 166     data.SetURL("http://foo.com/url?bar={searchTerms}");
 167     data.new_tab_url = new_tab_page_url.spec();
 168     TemplateURL* template_url = new TemplateURL(data);
 169     // Takes ownership.
 170     template_url_service->Add(template_url);
 171     template_url_service->SetUserSelectedDefaultSearchProvider(template_url);
 172   }
 173
 174   scoped_ptr<base::FieldTrialList> field_trial_list_;
 175 };
 176
 177 TEST_F(InstantNTPURLRewriteTest, UberURLHandler_InstantExtendedNewTabPage) {
 178   const GURL url_original("chrome://newtab");
 179   const GURL url_rewritten("https://www.example.com/newtab");
 180   InstallTemplateURLWithNewTabPage(url_rewritten);
 181   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("InstantExtended",
 182       "Group1 use_cacheable_ntp:1"));
 183
 184   AddTab(browser(), GURL("chrome://blank"));
 185   NavigateAndCommitActiveTab(url_original);
 186
 187   NavigationEntry* entry = browser()->tab_strip_model()->
 188       GetActiveWebContents()->GetController().GetLastCommittedEntry();
 189   ASSERT_TRUE(entry != NULL);
 190   EXPECT_EQ(url_rewritten, entry->GetURL());
 191   EXPECT_EQ(url_original, entry->GetVirtualURL());
 192 }
 193
 194 }  // namespace content
 195 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
 196
 197 namespace chrome {
 198
 199 // For testing permissions related functionality.
 200 class PermissionBrowserClientTest : public testing::Test {
 201  public:
 202   PermissionBrowserClientTest() : url_("https://www.google.com") {}
 203
 204   void CheckPermissionStatus(content::PermissionType type,
 205                              content::PermissionStatus expected) {
 206     EXPECT_EQ(expected, client_.GetPermissionStatus(type, &profile_,
 207                                                     url_.GetOrigin(),
 208                                                     url_.GetOrigin()));
 209   }
 210
 211   void SetPermission(ContentSettingsType type, ContentSetting value) {
 212     profile_.GetHostContentSettingsMap()->SetContentSetting(
 213         ContentSettingsPattern::FromURLNoWildcard(url_),
 214         ContentSettingsPattern::FromURLNoWildcard(url_),
 215         type, std::string(), value);
 216   }
 217
 218  private:
 219   content::TestBrowserThreadBundle thread_bundle_;
 220   ChromeContentBrowserClient client_;
 221   TestingProfile profile_;
 222   GURL url_;
 223 };
 224
 225 TEST_F(PermissionBrowserClientTest, GetPermissionStatusDefault) {
 226   using namespace content;
 227   CheckPermissionStatus(PERMISSION_MIDI_SYSEX, PERMISSION_STATUS_ASK);
 228   CheckPermissionStatus(PERMISSION_PUSH_MESSAGING, PERMISSION_STATUS_ASK);
 229   CheckPermissionStatus(PERMISSION_NOTIFICATIONS, PERMISSION_STATUS_ASK);
 230   CheckPermissionStatus(PERMISSION_GEOLOCATION, PERMISSION_STATUS_ASK);
 231 #if defined(OS_ANDROID)
 232   CheckPermissionStatus(PERMISSION_PROTECTED_MEDIA_IDENTIFIER,
 233                         PERMISSION_STATUS_ASK);
 234 #endif
 235 }
 236
 237 TEST_F(PermissionBrowserClientTest, GetPermissionStatusAfterSet) {
 238   using namespace content;
 239   SetPermission(CONTENT_SETTINGS_TYPE_GEOLOCATION, CONTENT_SETTING_ALLOW);
 240   CheckPermissionStatus(PERMISSION_GEOLOCATION, PERMISSION_STATUS_GRANTED);
 241
 242   SetPermission(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_ALLOW);
 243   CheckPermissionStatus(PERMISSION_NOTIFICATIONS, PERMISSION_STATUS_GRANTED);
 244
 245   SetPermission(CONTENT_SETTINGS_TYPE_MIDI_SYSEX, CONTENT_SETTING_ALLOW);
 246   CheckPermissionStatus(PERMISSION_MIDI_SYSEX, PERMISSION_STATUS_GRANTED);
 247
 248   SetPermission(CONTENT_SETTINGS_TYPE_PUSH_MESSAGING, CONTENT_SETTING_ALLOW);
 249   CheckPermissionStatus(PERMISSION_PUSH_MESSAGING, PERMISSION_STATUS_GRANTED);
 250
 251 #if defined(OS_ANDROID)
 252   SetPermission(CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER,
 253                 CONTENT_SETTING_ALLOW);
 254   CheckPermissionStatus(PERMISSION_PROTECTED_MEDIA_IDENTIFIER,
 255                         PERMISSION_STATUS_GRANTED);
 256 #endif
 257 }
 258
 259 }  // namespace chrome