1 // Copyright (c) 2012 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 <algorithm> 6 #include <string> 7 #include <vector> 8 9 #include "base/bind.h" 10 #include "base/bind_helpers.h" 11 #include "base/callback.h" 12 #include "base/command_line.h" 13 #include "base/file_util.h" 14 #include "base/files/file_enumerator.h" 15 #include "base/files/file_path.h" 16 #include "base/files/scoped_temp_dir.h" 17 #include "base/memory/ref_counted.h" 18 #include "base/path_service.h" 19 #include "base/prefs/pref_service.h" 20 #include "base/run_loop.h" 21 #include "base/strings/string16.h" 22 #include "base/strings/string_util.h" 23 #include "base/strings/stringprintf.h" 24 #include "base/strings/utf_string_conversions.h" 25 #include "base/test/test_file_util.h" 26 #include "base/time/time.h" 27 #include "base/values.h" 28 #include "chrome/app/chrome_command_ids.h" 29 #include "chrome/browser/autocomplete/autocomplete_controller.h" 30 #include "chrome/browser/background/background_contents_service.h" 31 #include "chrome/browser/browser_process.h" 32 #include "chrome/browser/chrome_notification_types.h" 33 #include "chrome/browser/content_settings/tab_specific_content_settings.h" 34 #include "chrome/browser/devtools/devtools_window.h" 35 #include "chrome/browser/download/download_prefs.h" 36 #include "chrome/browser/extensions/api/messaging/native_message_process_host.h" 37 #include "chrome/browser/extensions/crx_installer.h" 38 #include "chrome/browser/extensions/extension_service.h" 39 #include "chrome/browser/extensions/unpacked_installer.h" 40 #include "chrome/browser/extensions/updater/extension_cache_fake.h" 41 #include "chrome/browser/extensions/updater/extension_updater.h" 42 #include "chrome/browser/infobars/infobar_service.h" 43 #include "chrome/browser/media/media_capture_devices_dispatcher.h" 44 #include "chrome/browser/media/media_stream_devices_controller.h" 45 #include "chrome/browser/metrics/variations/variations_service.h" 46 #include "chrome/browser/net/url_request_mock_util.h" 47 #include "chrome/browser/plugins/plugin_prefs.h" 48 #include "chrome/browser/policy/cloud/test_request_interceptor.h" 49 #include "chrome/browser/policy/profile_policy_connector.h" 50 #include "chrome/browser/policy/profile_policy_connector_factory.h" 51 #include "chrome/browser/prefs/session_startup_pref.h" 52 #include "chrome/browser/profiles/profile.h" 53 #include "chrome/browser/search/instant_service.h" 54 #include "chrome/browser/search/instant_service_factory.h" 55 #include "chrome/browser/search/search.h" 56 #include "chrome/browser/search_engines/template_url.h" 57 #include "chrome/browser/search_engines/template_url_service.h" 58 #include "chrome/browser/search_engines/template_url_service_factory.h" 59 #include "chrome/browser/translate/chrome_translate_client.h" 60 #include "chrome/browser/translate/translate_browser_test_utils.h" 61 #include "chrome/browser/translate/translate_service.h" 62 #include "chrome/browser/ui/bookmarks/bookmark_bar.h" 63 #include "chrome/browser/ui/browser.h" 64 #include "chrome/browser/ui/browser_commands.h" 65 #include "chrome/browser/ui/browser_list.h" 66 #include "chrome/browser/ui/browser_tabstrip.h" 67 #include "chrome/browser/ui/browser_window.h" 68 #include "chrome/browser/ui/host_desktop.h" 69 #include "chrome/browser/ui/omnibox/location_bar.h" 70 #include "chrome/browser/ui/omnibox/omnibox_edit_model.h" 71 #include "chrome/browser/ui/omnibox/omnibox_view.h" 72 #include "chrome/browser/ui/tabs/tab_strip_model.h" 73 #include "chrome/common/chrome_paths.h" 74 #include "chrome/common/chrome_switches.h" 75 #include "chrome/common/content_settings.h" 76 #include "chrome/common/content_settings_pattern.h" 77 #include "chrome/common/extensions/extension_constants.h" 78 #include "chrome/common/pref_names.h" 79 #include "chrome/common/url_constants.h" 80 #include "chrome/test/base/in_process_browser_test.h" 81 #include "chrome/test/base/test_switches.h" 82 #include "chrome/test/base/ui_test_utils.h" 83 #include "components/infobars/core/infobar.h" 84 #include "components/policy/core/browser/browser_policy_connector.h" 85 #include "components/policy/core/common/external_data_fetcher.h" 86 #include "components/policy/core/common/mock_configuration_policy_provider.h" 87 #include "components/policy/core/common/policy_map.h" 88 #include "components/policy/core/common/policy_pref_names.h" 89 #include "components/policy/core/common/policy_service.h" 90 #include "components/policy/core/common/policy_service_impl.h" 91 #include "components/translate/core/browser/language_state.h" 92 #include "components/translate/core/browser/translate_infobar_delegate.h" 93 #include "content/public/browser/browser_child_process_host_iterator.h" 94 #include "content/public/browser/browser_context.h" 95 #include "content/public/browser/browser_thread.h" 96 #include "content/public/browser/child_process_data.h" 97 #include "content/public/browser/download_item.h" 98 #include "content/public/browser/download_manager.h" 99 #include "content/public/browser/gpu_data_manager.h" 100 #include "content/public/browser/notification_details.h" 101 #include "content/public/browser/notification_observer.h" 102 #include "content/public/browser/notification_registrar.h" 103 #include "content/public/browser/notification_service.h" 104 #include "content/public/browser/notification_source.h" 105 #include "content/public/browser/notification_types.h" 106 #include "content/public/browser/plugin_service.h" 107 #include "content/public/browser/render_process_host.h" 108 #include "content/public/browser/render_view_host.h" 109 #include "content/public/browser/web_contents.h" 110 #include "content/public/common/content_constants.h" 111 #include "content/public/common/content_paths.h" 112 #include "content/public/common/page_transition_types.h" 113 #include "content/public/common/process_type.h" 114 #include "content/public/common/result_codes.h" 115 #include "content/public/common/url_constants.h" 116 #include "content/public/common/webplugininfo.h" 117 #include "content/public/test/browser_test_utils.h" 118 #include "content/public/test/download_test_observer.h" 119 #include "content/public/test/mock_notification_observer.h" 120 #include "content/public/test/test_navigation_observer.h" 121 #include "content/public/test/test_utils.h" 122 #include "content/test/net/url_request_failed_job.h" 123 #include "content/test/net/url_request_mock_http_job.h" 124 #include "extensions/browser/extension_host.h" 125 #include "extensions/browser/extension_system.h" 126 #include "extensions/browser/process_manager.h" 127 #include "extensions/common/constants.h" 128 #include "extensions/common/extension.h" 129 #include "extensions/common/extension_set.h" 130 #include "grit/generated_resources.h" 131 #include "net/base/net_errors.h" 132 #include "net/base/net_util.h" 133 #include "net/base/url_util.h" 134 #include "net/http/http_stream_factory.h" 135 #include "net/url_request/url_request.h" 136 #include "net/url_request/url_request_filter.h" 137 #include "policy/policy_constants.h" 138 #include "testing/gmock/include/gmock/gmock.h" 139 #include "testing/gtest/include/gtest/gtest.h" 140 #include "third_party/WebKit/public/web/WebInputEvent.h" 141 #include "ui/base/l10n/l10n_util.h" 142 #include "ui/base/resource/resource_bundle.h" 143 #include "url/gurl.h" 144 145 #if defined(OS_CHROMEOS) 146 #include "ash/accelerators/accelerator_controller.h" 147 #include "ash/accelerators/accelerator_table.h" 148 #include "ash/magnifier/magnifier_constants.h" 149 #include "ash/shell.h" 150 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h" 151 #include "chrome/browser/chromeos/accessibility/magnification_manager.h" 152 #include "chrome/browser/profiles/profile_manager.h" 153 #include "chrome/browser/ui/ash/screenshot_taker.h" 154 #include "chromeos/audio/cras_audio_handler.h" 155 #include "ui/keyboard/keyboard_util.h" 156 #endif 157 158 #if !defined(OS_MACOSX) 159 #include "apps/app_window.h" 160 #include "apps/app_window_registry.h" 161 #include "apps/ui/native_app_window.h" 162 #include "base/basictypes.h" 163 #include "base/compiler_specific.h" 164 #include "chrome/browser/ui/extensions/application_launch.h" 165 #include "ui/base/window_open_disposition.h" 166 #endif 167 168 using content::BrowserThread; 169 using content::URLRequestMockHTTPJob; 170 using testing::Mock; 171 using testing::Return; 172 using testing::_; 173 174 namespace policy { 175 176 namespace { 177 178 #if defined(OS_CHROMEOS) 179 const int kOneHourInMs = 60 * 60 * 1000; 180 const int kThreeHoursInMs = 180 * 60 * 1000; 181 #endif 182 183 const char kURL[] = "http://example.com"; 184 const char kCookieValue[] = "converted=true"; 185 // Assigned to Philip J. Fry to fix eventually. 186 const char kCookieOptions[] = ";expires=Wed Jan 01 3000 00:00:00 GMT"; 187 188 const base::FilePath::CharType kTestExtensionsDir[] = 189 FILE_PATH_LITERAL("extensions"); 190 const base::FilePath::CharType kGoodCrxName[] = FILE_PATH_LITERAL("good.crx"); 191 const base::FilePath::CharType kAdBlockCrxName[] = 192 FILE_PATH_LITERAL("adblock.crx"); 193 const base::FilePath::CharType kHostedAppCrxName[] = 194 FILE_PATH_LITERAL("hosted_app.crx"); 195 196 const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf"; 197 const char kAdBlockCrxId[] = "dojnnbeimaimaojcialkkgajdnefpgcn"; 198 const char kHostedAppCrxId[] = "kbmnembihfiondgfjekmnmcbddelicoi"; 199 200 const base::FilePath::CharType kGood2CrxManifestName[] = 201 FILE_PATH_LITERAL("good2_update_manifest.xml"); 202 const base::FilePath::CharType kGoodV1CrxManifestName[] = 203 FILE_PATH_LITERAL("good_v1_update_manifest.xml"); 204 const base::FilePath::CharType kGoodUnpackedExt[] = 205 FILE_PATH_LITERAL("good_unpacked"); 206 const base::FilePath::CharType kAppUnpackedExt[] = 207 FILE_PATH_LITERAL("app"); 208 209 #if !defined(OS_MACOSX) 210 const base::FilePath::CharType kUnpackedFullscreenAppName[] = 211 FILE_PATH_LITERAL("fullscreen_app"); 212 #endif // !defined(OS_MACOSX) 213 214 // Filters requests to the hosts in |urls| and redirects them to the test data 215 // dir through URLRequestMockHTTPJobs. 216 void RedirectHostsToTestData(const char* const urls[], size_t size) { 217 // Map the given hosts to the test data dir. 218 net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance(); 219 base::FilePath base_path; 220 PathService::Get(chrome::DIR_TEST_DATA, &base_path); 221 for (size_t i = 0; i < size; ++i) { 222 const GURL url(urls[i]); 223 EXPECT_TRUE(url.is_valid()); 224 filter->AddUrlInterceptor( 225 url, URLRequestMockHTTPJob::CreateInterceptor(base_path)); 226 } 227 } 228 229 // Remove filters for requests to the hosts in |urls|. 230 void UndoRedirectHostsToTestData(const char* const urls[], size_t size) { 231 // Map the given hosts to the test data dir. 232 net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance(); 233 for (size_t i = 0; i < size; ++i) { 234 const GURL url(urls[i]); 235 EXPECT_TRUE(url.is_valid()); 236 filter->RemoveUrlHandler(url); 237 } 238 } 239 240 // Fails requests using ERR_CONNECTION_RESET. 241 net::URLRequestJob* FailedJobFactory( 242 net::URLRequest* request, 243 net::NetworkDelegate* network_delegate, 244 const std::string& scheme) { 245 return new content::URLRequestFailedJob( 246 request, network_delegate, net::ERR_CONNECTION_RESET); 247 } 248 249 // While |MakeRequestFail| is in scope URLRequests to |host| will fail. 250 class MakeRequestFail { 251 public: 252 // Sets up the filter on IO thread such that requests to |host| fail. 253 explicit MakeRequestFail(const std::string& host) : host_(host) { 254 BrowserThread::PostTaskAndReply( 255 BrowserThread::IO, FROM_HERE, 256 base::Bind(MakeRequestFailOnIO, host_), 257 base::MessageLoop::QuitClosure()); 258 content::RunMessageLoop(); 259 } 260 ~MakeRequestFail() { 261 BrowserThread::PostTaskAndReply( 262 BrowserThread::IO, FROM_HERE, 263 base::Bind(UndoMakeRequestFailOnIO, host_), 264 base::MessageLoop::QuitClosure()); 265 content::RunMessageLoop(); 266 } 267 268 private: 269 // Filters requests to the |host| such that they fail. Run on IO thread. 270 static void MakeRequestFailOnIO(const std::string& host) { 271 net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance(); 272 filter->AddHostnameHandler("http", host, &FailedJobFactory); 273 filter->AddHostnameHandler("https", host, &FailedJobFactory); 274 } 275 276 // Remove filters for requests to the |host|. Run on IO thread. 277 static void UndoMakeRequestFailOnIO(const std::string& host) { 278 net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance(); 279 filter->RemoveHostnameHandler("http", host); 280 filter->RemoveHostnameHandler("https", host); 281 } 282 283 const std::string host_; 284 }; 285 286 // Verifies that the given url |spec| can be opened. This assumes that |spec| 287 // points at empty.html in the test data dir. 288 void CheckCanOpenURL(Browser* browser, const char* spec) { 289 GURL url(spec); 290 ui_test_utils::NavigateToURL(browser, url); 291 content::WebContents* contents = 292 browser->tab_strip_model()->GetActiveWebContents(); 293 EXPECT_EQ(url, contents->GetURL()); 294 base::string16 title = base::UTF8ToUTF16(url.spec() + " was blocked"); 295 EXPECT_NE(title, contents->GetTitle()); 296 } 297 298 // Verifies that access to the given url |spec| is blocked. 299 void CheckURLIsBlocked(Browser* browser, const char* spec) { 300 GURL url(spec); 301 ui_test_utils::NavigateToURL(browser, url); 302 content::WebContents* contents = 303 browser->tab_strip_model()->GetActiveWebContents(); 304 EXPECT_EQ(url, contents->GetURL()); 305 base::string16 title = base::UTF8ToUTF16(url.spec() + " was blocked"); 306 EXPECT_EQ(title, contents->GetTitle()); 307 308 // Verify that the expected error page is being displayed. 309 bool result = false; 310 EXPECT_TRUE(content::ExecuteScriptAndExtractBool( 311 contents, 312 "var textContent = document.body.textContent;" 313 "var hasError = textContent.indexOf('ERR_BLOCKED_BY_ADMINISTRATOR') >= 0;" 314 "domAutomationController.send(hasError);", 315 &result)); 316 EXPECT_TRUE(result); 317 } 318 319 // Downloads a file named |file| and expects it to be saved to |dir|, which 320 // must be empty. 321 void DownloadAndVerifyFile( 322 Browser* browser, const base::FilePath& dir, const base::FilePath& file) { 323 content::DownloadManager* download_manager = 324 content::BrowserContext::GetDownloadManager(browser->profile()); 325 content::DownloadTestObserverTerminal observer( 326 download_manager, 1, 327 content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL); 328 GURL url(URLRequestMockHTTPJob::GetMockUrl(file)); 329 base::FilePath downloaded = dir.Append(file); 330 EXPECT_FALSE(base::PathExists(downloaded)); 331 ui_test_utils::NavigateToURLWithDisposition( 332 browser, url, CURRENT_TAB, 333 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 334 observer.WaitForFinished(); 335 EXPECT_EQ( 336 1u, observer.NumDownloadsSeenInState(content::DownloadItem::COMPLETE)); 337 EXPECT_TRUE(base::PathExists(downloaded)); 338 base::FileEnumerator enumerator(dir, false, base::FileEnumerator::FILES); 339 EXPECT_EQ(file, enumerator.Next().BaseName()); 340 EXPECT_EQ(base::FilePath(), enumerator.Next()); 341 } 342 343 #if defined(OS_CHROMEOS) 344 int CountScreenshots() { 345 DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext( 346 ProfileManager::GetActiveUserProfile()); 347 base::FileEnumerator enumerator(download_prefs->DownloadPath(), 348 false, base::FileEnumerator::FILES, 349 "Screenshot*"); 350 int count = 0; 351 while (!enumerator.Next().empty()) 352 count++; 353 return count; 354 } 355 #endif 356 357 // Checks if WebGL is enabled in the given WebContents. 358 bool IsWebGLEnabled(content::WebContents* contents) { 359 bool result = false; 360 EXPECT_TRUE(content::ExecuteScriptAndExtractBool( 361 contents, 362 "var canvas = document.createElement('canvas');" 363 "var context = canvas.getContext('webgl');" 364 "domAutomationController.send(context != null);", 365 &result)); 366 return result; 367 } 368 369 bool IsJavascriptEnabled(content::WebContents* contents) { 370 scoped_ptr<base::Value> value = content::ExecuteScriptAndGetValue( 371 contents->GetMainFrame(), "123"); 372 int result = 0; 373 if (!value->GetAsInteger(&result)) 374 EXPECT_EQ(base::Value::TYPE_NULL, value->GetType()); 375 return result == 123; 376 } 377 378 void CopyPluginListAndQuit(std::vector<content::WebPluginInfo>* out, 379 const std::vector<content::WebPluginInfo>& in) { 380 *out = in; 381 base::MessageLoop::current()->QuitWhenIdle(); 382 } 383 384 template<typename T> 385 void CopyValueAndQuit(T* out, T in) { 386 *out = in; 387 base::MessageLoop::current()->QuitWhenIdle(); 388 } 389 390 void GetPluginList(std::vector<content::WebPluginInfo>* plugins) { 391 content::PluginService* service = content::PluginService::GetInstance(); 392 service->GetPlugins(base::Bind(CopyPluginListAndQuit, plugins)); 393 content::RunMessageLoop(); 394 } 395 396 const content::WebPluginInfo* GetFlashPlugin( 397 const std::vector<content::WebPluginInfo>& plugins) { 398 const content::WebPluginInfo* flash = NULL; 399 for (size_t i = 0; i < plugins.size(); ++i) { 400 if (plugins[i].name == base::ASCIIToUTF16(content::kFlashPluginName)) { 401 flash = &plugins[i]; 402 break; 403 } 404 } 405 #if defined(OFFICIAL_BUILD) 406 // Official builds bundle Flash. 407 EXPECT_TRUE(flash); 408 #else 409 if (!flash) 410 LOG(INFO) << "Test skipped because the Flash plugin couldn't be found."; 411 #endif 412 return flash; 413 } 414 415 bool SetPluginEnabled(PluginPrefs* plugin_prefs, 416 const content::WebPluginInfo* plugin, 417 bool enabled) { 418 bool ok = false; 419 plugin_prefs->EnablePlugin(enabled, plugin->path, 420 base::Bind(CopyValueAndQuit<bool>, &ok)); 421 content::RunMessageLoop(); 422 return ok; 423 } 424 425 int CountPluginsOnIOThread() { 426 int count = 0; 427 for (content::BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) { 428 if (iter.GetData().process_type == content::PROCESS_TYPE_PLUGIN || 429 iter.GetData().process_type == content::PROCESS_TYPE_PPAPI_PLUGIN) { 430 count++; 431 } 432 } 433 return count; 434 } 435 436 int CountPlugins() { 437 int count = -1; 438 BrowserThread::PostTaskAndReplyWithResult( 439 BrowserThread::IO, FROM_HERE, 440 base::Bind(CountPluginsOnIOThread), 441 base::Bind(CopyValueAndQuit<int>, &count)); 442 content::RunMessageLoop(); 443 EXPECT_GE(count, 0); 444 return count; 445 } 446 447 void FlushBlacklistPolicy() { 448 // Updates of the URLBlacklist are done on IO, after building the blacklist 449 // on FILE, which is initiated from IO. 450 content::RunAllPendingInMessageLoop(BrowserThread::IO); 451 content::RunAllPendingInMessageLoop(BrowserThread::FILE); 452 content::RunAllPendingInMessageLoop(BrowserThread::IO); 453 } 454 455 bool ContainsVisibleElement(content::WebContents* contents, 456 const std::string& id) { 457 bool result; 458 EXPECT_TRUE(content::ExecuteScriptAndExtractBool( 459 contents, 460 "var elem = document.getElementById('" + id + "');" 461 "domAutomationController.send(!!elem && !elem.hidden);", 462 &result)); 463 return result; 464 } 465 466 #if defined(OS_CHROMEOS) 467 class TestAudioObserver : public chromeos::CrasAudioHandler::AudioObserver { 468 public: 469 TestAudioObserver() : output_mute_changed_count_(0) { 470 } 471 472 int output_mute_changed_count() const { 473 return output_mute_changed_count_; 474 } 475 476 virtual ~TestAudioObserver() {} 477 478 protected: 479 // chromeos::CrasAudioHandler::AudioObserver overrides. 480 virtual void OnOutputMuteChanged() OVERRIDE { 481 ++output_mute_changed_count_; 482 } 483 484 private: 485 int output_mute_changed_count_; 486 487 DISALLOW_COPY_AND_ASSIGN(TestAudioObserver); 488 }; 489 #endif 490 491 // This class waits until either a load stops or the WebContents is destroyed. 492 class WebContentsLoadedOrDestroyedWatcher 493 : public content::WebContentsObserver { 494 public: 495 explicit WebContentsLoadedOrDestroyedWatcher( 496 content::WebContents* web_contents); 497 virtual ~WebContentsLoadedOrDestroyedWatcher(); 498 499 // Waits until the WebContents's load is done or until it is destroyed. 500 void Wait(); 501 502 // Overridden WebContentsObserver methods. 503 virtual void WebContentsDestroyed() OVERRIDE; 504 virtual void DidStopLoading( 505 content::RenderViewHost* render_view_host) OVERRIDE; 506 507 private: 508 scoped_refptr<content::MessageLoopRunner> message_loop_runner_; 509 510 DISALLOW_COPY_AND_ASSIGN(WebContentsLoadedOrDestroyedWatcher); 511 }; 512 513 WebContentsLoadedOrDestroyedWatcher::WebContentsLoadedOrDestroyedWatcher( 514 content::WebContents* web_contents) 515 : content::WebContentsObserver(web_contents), 516 message_loop_runner_(new content::MessageLoopRunner) { 517 } 518 519 WebContentsLoadedOrDestroyedWatcher::~WebContentsLoadedOrDestroyedWatcher() {} 520 521 void WebContentsLoadedOrDestroyedWatcher::Wait() { 522 message_loop_runner_->Run(); 523 } 524 525 void WebContentsLoadedOrDestroyedWatcher::WebContentsDestroyed() { 526 message_loop_runner_->Quit(); 527 } 528 529 void WebContentsLoadedOrDestroyedWatcher::DidStopLoading( 530 content::RenderViewHost* render_view_host) { 531 message_loop_runner_->Quit(); 532 } 533 534 #if !defined(OS_MACOSX) 535 536 // Observer used to wait for the creation of a new app window. 537 class TestAddAppWindowObserver : public apps::AppWindowRegistry::Observer { 538 public: 539 explicit TestAddAppWindowObserver(apps::AppWindowRegistry* registry); 540 virtual ~TestAddAppWindowObserver(); 541 542 // apps::AppWindowRegistry::Observer: 543 virtual void OnAppWindowAdded(apps::AppWindow* app_window) OVERRIDE; 544 545 apps::AppWindow* WaitForAppWindow(); 546 547 private: 548 apps::AppWindowRegistry* registry_; // Not owned. 549 apps::AppWindow* window_; // Not owned. 550 base::RunLoop run_loop_; 551 552 DISALLOW_COPY_AND_ASSIGN(TestAddAppWindowObserver); 553 }; 554 555 TestAddAppWindowObserver::TestAddAppWindowObserver( 556 apps::AppWindowRegistry* registry) 557 : registry_(registry), window_(NULL) { 558 registry_->AddObserver(this); 559 } 560 561 TestAddAppWindowObserver::~TestAddAppWindowObserver() { 562 registry_->RemoveObserver(this); 563 } 564 565 void TestAddAppWindowObserver::OnAppWindowAdded(apps::AppWindow* app_window) { 566 window_ = app_window; 567 run_loop_.Quit(); 568 } 569 570 apps::AppWindow* TestAddAppWindowObserver::WaitForAppWindow() { 571 run_loop_.Run(); 572 return window_; 573 } 574 575 #endif 576 577 } // namespace 578 579 class PolicyTest : public InProcessBrowserTest { 580 protected: 581 PolicyTest() {} 582 virtual ~PolicyTest() {} 583 584 virtual void SetUp() OVERRIDE { 585 test_extension_cache_.reset(new extensions::ExtensionCacheFake()); 586 InProcessBrowserTest::SetUp(); 587 } 588 589 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE { 590 CommandLine::ForCurrentProcess()->AppendSwitch("noerrdialogs"); 591 EXPECT_CALL(provider_, IsInitializationComplete(_)) 592 .WillRepeatedly(Return(true)); 593 BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_); 594 } 595 596 virtual void SetUpOnMainThread() OVERRIDE { 597 BrowserThread::PostTask( 598 BrowserThread::IO, FROM_HERE, 599 base::Bind(chrome_browser_net::SetUrlRequestMocksEnabled, true)); 600 } 601 602 // Makes URLRequestMockHTTPJobs serve data from content::DIR_TEST_DATA 603 // instead of chrome::DIR_TEST_DATA. 604 void ServeContentTestData() { 605 base::FilePath root_http; 606 PathService::Get(content::DIR_TEST_DATA, &root_http); 607 BrowserThread::PostTaskAndReply( 608 BrowserThread::IO, FROM_HERE, 609 base::Bind(URLRequestMockHTTPJob::AddUrlHandler, root_http), 610 base::MessageLoop::current()->QuitWhenIdleClosure()); 611 content::RunMessageLoop(); 612 } 613 614 void SetScreenshotPolicy(bool enabled) { 615 PolicyMap policies; 616 policies.Set(key::kDisableScreenshots, 617 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 618 base::Value::CreateBooleanValue(!enabled), NULL); 619 UpdateProviderPolicy(policies); 620 } 621 622 #if defined(OS_CHROMEOS) 623 class QuitMessageLoopAfterScreenshot : public ScreenshotTakerObserver { 624 public: 625 virtual void OnScreenshotCompleted( 626 ScreenshotTakerObserver::Result screenshot_result, 627 const base::FilePath& screenshot_path) OVERRIDE { 628 BrowserThread::PostTaskAndReply(BrowserThread::IO, 629 FROM_HERE, 630 base::Bind(base::DoNothing), 631 base::MessageLoop::QuitClosure()); 632 } 633 634 virtual ~QuitMessageLoopAfterScreenshot() {} 635 }; 636 637 void TestScreenshotFile(bool enabled) { 638 // AddObserver is an ash-specific method, so just replace the screenshot 639 // taker with one we've created here. 640 scoped_ptr<ScreenshotTaker> screenshot_taker(new ScreenshotTaker); 641 // ScreenshotTaker doesn't own this observer, so the observer's lifetime 642 // is tied to the test instead. 643 screenshot_taker->AddObserver(&observer_); 644 ash::Shell::GetInstance()->accelerator_controller()->SetScreenshotDelegate( 645 screenshot_taker.PassAs<ash::ScreenshotDelegate>()); 646 647 SetScreenshotPolicy(enabled); 648 ash::Shell::GetInstance()->accelerator_controller()->PerformAction( 649 ash::TAKE_SCREENSHOT, ui::Accelerator()); 650 651 content::RunMessageLoop(); 652 } 653 #endif 654 655 ExtensionService* extension_service() { 656 extensions::ExtensionSystem* system = 657 extensions::ExtensionSystem::Get(browser()->profile()); 658 return system->extension_service(); 659 } 660 661 const extensions::Extension* InstallExtension( 662 const base::FilePath::StringType& name) { 663 base::FilePath extension_path(ui_test_utils::GetTestFilePath( 664 base::FilePath(kTestExtensionsDir), base::FilePath(name))); 665 scoped_refptr<extensions::CrxInstaller> installer = 666 extensions::CrxInstaller::CreateSilent(extension_service()); 667 installer->set_allow_silent_install(true); 668 installer->set_install_cause(extension_misc::INSTALL_CAUSE_UPDATE); 669 installer->set_creation_flags(extensions::Extension::FROM_WEBSTORE); 670 671 content::WindowedNotificationObserver observer( 672 chrome::NOTIFICATION_CRX_INSTALLER_DONE, 673 content::NotificationService::AllSources()); 674 installer->InstallCrx(extension_path); 675 observer.Wait(); 676 content::Details<const extensions::Extension> details = observer.details(); 677 return details.ptr(); 678 } 679 680 const extensions::Extension* LoadUnpackedExtension( 681 const base::FilePath::StringType& name, bool expect_success) { 682 base::FilePath extension_path(ui_test_utils::GetTestFilePath( 683 base::FilePath(kTestExtensionsDir), base::FilePath(name))); 684 scoped_refptr<extensions::UnpackedInstaller> installer = 685 extensions::UnpackedInstaller::Create(extension_service()); 686 content::WindowedNotificationObserver observer( 687 expect_success ? chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED 688 : chrome::NOTIFICATION_EXTENSION_LOAD_ERROR, 689 content::NotificationService::AllSources()); 690 installer->Load(extension_path); 691 observer.Wait(); 692 693 const extensions::ExtensionSet* extensions = 694 extension_service()->extensions(); 695 for (extensions::ExtensionSet::const_iterator it = extensions->begin(); 696 it != extensions->end(); ++it) { 697 if ((*it)->path() == extension_path) 698 return it->get(); 699 } 700 return NULL; 701 } 702 703 void UninstallExtension(const std::string& id, bool expect_success) { 704 content::WindowedNotificationObserver observer( 705 expect_success ? chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED 706 : chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED, 707 content::NotificationService::AllSources()); 708 extension_service()->UninstallExtension(id, false, NULL); 709 observer.Wait(); 710 } 711 712 void UpdateProviderPolicy(const PolicyMap& policy) { 713 provider_.UpdateChromePolicy(policy); 714 DCHECK(base::MessageLoop::current()); 715 base::RunLoop loop; 716 loop.RunUntilIdle(); 717 } 718 719 // Sends a mouse click at the given coordinates to the current renderer. 720 void PerformClick(int x, int y) { 721 content::WebContents* contents = 722 browser()->tab_strip_model()->GetActiveWebContents(); 723 blink::WebMouseEvent click_event; 724 click_event.type = blink::WebInputEvent::MouseDown; 725 click_event.button = blink::WebMouseEvent::ButtonLeft; 726 click_event.clickCount = 1; 727 click_event.x = x; 728 click_event.y = y; 729 contents->GetRenderViewHost()->ForwardMouseEvent(click_event); 730 click_event.type = blink::WebInputEvent::MouseUp; 731 contents->GetRenderViewHost()->ForwardMouseEvent(click_event); 732 } 733 734 MockConfigurationPolicyProvider provider_; 735 scoped_ptr<extensions::ExtensionCacheFake> test_extension_cache_; 736 #if defined(OS_CHROMEOS) 737 QuitMessageLoopAfterScreenshot observer_; 738 #endif 739 }; 740 741 #if defined(OS_WIN) 742 // This policy only exists on Windows. 743 744 // Sets the locale policy before the browser is started. 745 class LocalePolicyTest : public PolicyTest { 746 public: 747 LocalePolicyTest() {} 748 virtual ~LocalePolicyTest() {} 749 750 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE { 751 PolicyTest::SetUpInProcessBrowserTestFixture(); 752 PolicyMap policies; 753 policies.Set( 754 key::kApplicationLocaleValue, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 755 base::Value::CreateStringValue("fr"), NULL); 756 provider_.UpdateChromePolicy(policies); 757 // The "en-US" ResourceBundle is always loaded before this step for tests, 758 // but in this test we want the browser to load the bundle as it 759 // normally would. 760 ResourceBundle::CleanupSharedInstance(); 761 } 762 }; 763 764 IN_PROC_BROWSER_TEST_F(LocalePolicyTest, ApplicationLocaleValue) { 765 // Verifies that the default locale can be overridden with policy. 766 EXPECT_EQ("fr", g_browser_process->GetApplicationLocale()); 767 ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL)); 768 base::string16 french_title = l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE); 769 base::string16 title; 770 EXPECT_TRUE(ui_test_utils::GetCurrentTabTitle(browser(), &title)); 771 EXPECT_EQ(french_title, title); 772 773 // Make sure this is really French and differs from the English title. 774 std::string loaded = 775 ui::ResourceBundle::GetSharedInstance().ReloadLocaleResources("en-US"); 776 EXPECT_EQ("en-US", loaded); 777 base::string16 english_title = l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE); 778 EXPECT_NE(french_title, english_title); 779 } 780 #endif 781 782 IN_PROC_BROWSER_TEST_F(PolicyTest, BookmarkBarEnabled) { 783 #if defined(OS_WIN) && defined(USE_ASH) 784 // Disable this test in Metro+Ash for now (http://crbug.com/262796). 785 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests)) 786 return; 787 #endif 788 789 // Verifies that the bookmarks bar can be forced to always or never show up. 790 791 // Test starts in about:blank. 792 PrefService* prefs = browser()->profile()->GetPrefs(); 793 EXPECT_FALSE(prefs->IsManagedPreference(prefs::kShowBookmarkBar)); 794 EXPECT_FALSE(prefs->GetBoolean(prefs::kShowBookmarkBar)); 795 EXPECT_EQ(BookmarkBar::HIDDEN, browser()->bookmark_bar_state()); 796 797 PolicyMap policies; 798 policies.Set(key::kBookmarkBarEnabled, POLICY_LEVEL_MANDATORY, 799 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 800 UpdateProviderPolicy(policies); 801 EXPECT_TRUE(prefs->IsManagedPreference(prefs::kShowBookmarkBar)); 802 EXPECT_TRUE(prefs->GetBoolean(prefs::kShowBookmarkBar)); 803 EXPECT_EQ(BookmarkBar::SHOW, browser()->bookmark_bar_state()); 804 805 // The NTP has special handling of the bookmark bar. 806 ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL)); 807 EXPECT_EQ(BookmarkBar::SHOW, browser()->bookmark_bar_state()); 808 809 policies.Set(key::kBookmarkBarEnabled, POLICY_LEVEL_MANDATORY, 810 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 811 UpdateProviderPolicy(policies); 812 EXPECT_TRUE(prefs->IsManagedPreference(prefs::kShowBookmarkBar)); 813 EXPECT_FALSE(prefs->GetBoolean(prefs::kShowBookmarkBar)); 814 // The bookmark bar is hidden in the NTP when disabled by policy. 815 EXPECT_EQ(BookmarkBar::HIDDEN, browser()->bookmark_bar_state()); 816 817 policies.Clear(); 818 UpdateProviderPolicy(policies); 819 EXPECT_FALSE(prefs->IsManagedPreference(prefs::kShowBookmarkBar)); 820 EXPECT_FALSE(prefs->GetBoolean(prefs::kShowBookmarkBar)); 821 // The bookmark bar is shown detached in the NTP, when disabled by prefs only. 822 EXPECT_EQ(BookmarkBar::DETACHED, browser()->bookmark_bar_state()); 823 } 824 825 IN_PROC_BROWSER_TEST_F(PolicyTest, PRE_PRE_DefaultCookiesSetting) { 826 // Verifies that cookies are deleted on shutdown. This test is split in 3 827 // parts because it spans 2 browser restarts. 828 829 Profile* profile = browser()->profile(); 830 GURL url(kURL); 831 // No cookies at startup. 832 EXPECT_TRUE(content::GetCookies(profile, url).empty()); 833 // Set a cookie now. 834 std::string value = std::string(kCookieValue) + std::string(kCookieOptions); 835 EXPECT_TRUE(content::SetCookie(profile, url, value)); 836 // Verify it was set. 837 EXPECT_EQ(kCookieValue, GetCookies(profile, url)); 838 } 839 840 IN_PROC_BROWSER_TEST_F(PolicyTest, PRE_DefaultCookiesSetting) { 841 // Verify that the cookie persists across restarts. 842 EXPECT_EQ(kCookieValue, GetCookies(browser()->profile(), GURL(kURL))); 843 // Now set the policy and the cookie should be gone after another restart. 844 PolicyMap policies; 845 policies.Set(key::kDefaultCookiesSetting, POLICY_LEVEL_MANDATORY, 846 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(4), NULL); 847 UpdateProviderPolicy(policies); 848 } 849 850 IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultCookiesSetting) { 851 // Verify that the cookie is gone. 852 EXPECT_TRUE(GetCookies(browser()->profile(), GURL(kURL)).empty()); 853 } 854 855 IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultSearchProvider) { 856 MakeRequestFail make_request_fail("search.example"); 857 858 // Verifies that a default search is made using the provider configured via 859 // policy. Also checks that default search can be completely disabled. 860 const base::string16 kKeyword(base::ASCIIToUTF16("testsearch")); 861 const std::string kSearchURL("http://search.example/search?q={searchTerms}"); 862 const std::string kAlternateURL0( 863 "http://search.example/search#q={searchTerms}"); 864 const std::string kAlternateURL1("http://search.example/#q={searchTerms}"); 865 const std::string kSearchTermsReplacementKey("zekey"); 866 const std::string kImageURL("http://test.com/searchbyimage/upload"); 867 const std::string kImageURLPostParams( 868 "image_content=content,image_url=http://test.com/test.png"); 869 const std::string kNewTabURL("http://search.example/newtab"); 870 871 TemplateURLService* service = TemplateURLServiceFactory::GetForProfile( 872 browser()->profile()); 873 ui_test_utils::WaitForTemplateURLServiceToLoad(service); 874 TemplateURL* default_search = service->GetDefaultSearchProvider(); 875 ASSERT_TRUE(default_search); 876 EXPECT_NE(kKeyword, default_search->keyword()); 877 EXPECT_NE(kSearchURL, default_search->url()); 878 EXPECT_FALSE( 879 default_search->alternate_urls().size() == 2 && 880 default_search->alternate_urls()[0] == kAlternateURL0 && 881 default_search->alternate_urls()[1] == kAlternateURL1 && 882 default_search->search_terms_replacement_key() == 883 kSearchTermsReplacementKey && 884 default_search->image_url() == kImageURL && 885 default_search->image_url_post_params() == kImageURLPostParams && 886 default_search->new_tab_url() == kNewTabURL); 887 888 // Override the default search provider using policies. 889 PolicyMap policies; 890 policies.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY, 891 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 892 policies.Set(key::kDefaultSearchProviderKeyword, 893 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 894 base::Value::CreateStringValue(kKeyword), NULL); 895 policies.Set(key::kDefaultSearchProviderSearchURL, 896 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 897 base::Value::CreateStringValue(kSearchURL), NULL); 898 base::ListValue* alternate_urls = new base::ListValue(); 899 alternate_urls->AppendString(kAlternateURL0); 900 alternate_urls->AppendString(kAlternateURL1); 901 policies.Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY, 902 POLICY_SCOPE_USER, alternate_urls, NULL); 903 policies.Set(key::kDefaultSearchProviderSearchTermsReplacementKey, 904 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 905 base::Value::CreateStringValue(kSearchTermsReplacementKey), 906 NULL); 907 policies.Set(key::kDefaultSearchProviderImageURL, 908 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 909 base::Value::CreateStringValue(kImageURL), 910 NULL); 911 policies.Set(key::kDefaultSearchProviderImageURLPostParams, 912 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 913 base::Value::CreateStringValue(kImageURLPostParams), 914 NULL); 915 policies.Set(key::kDefaultSearchProviderNewTabURL, 916 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 917 base::Value::CreateStringValue(kNewTabURL), 918 NULL); 919 UpdateProviderPolicy(policies); 920 default_search = service->GetDefaultSearchProvider(); 921 ASSERT_TRUE(default_search); 922 EXPECT_EQ(kKeyword, default_search->keyword()); 923 EXPECT_EQ(kSearchURL, default_search->url()); 924 EXPECT_EQ(2U, default_search->alternate_urls().size()); 925 EXPECT_EQ(kAlternateURL0, default_search->alternate_urls()[0]); 926 EXPECT_EQ(kAlternateURL1, default_search->alternate_urls()[1]); 927 EXPECT_EQ(kSearchTermsReplacementKey, 928 default_search->search_terms_replacement_key()); 929 EXPECT_EQ(kImageURL, default_search->image_url()); 930 EXPECT_EQ(kImageURLPostParams, default_search->image_url_post_params()); 931 EXPECT_EQ(kNewTabURL, default_search->new_tab_url()); 932 933 // Verify that searching from the omnibox uses kSearchURL. 934 chrome::FocusLocationBar(browser()); 935 LocationBar* location_bar = browser()->window()->GetLocationBar(); 936 ui_test_utils::SendToOmniboxAndSubmit(location_bar, "stuff to search for"); 937 OmniboxEditModel* model = location_bar->GetOmniboxView()->model(); 938 EXPECT_TRUE(model->CurrentMatch(NULL).destination_url.is_valid()); 939 content::WebContents* web_contents = 940 browser()->tab_strip_model()->GetActiveWebContents(); 941 GURL expected("http://search.example/search?q=stuff+to+search+for"); 942 EXPECT_EQ(expected, web_contents->GetURL()); 943 944 // Verify that searching from the omnibox can be disabled. 945 ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL)); 946 policies.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY, 947 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 948 EXPECT_TRUE(service->GetDefaultSearchProvider()); 949 UpdateProviderPolicy(policies); 950 EXPECT_FALSE(service->GetDefaultSearchProvider()); 951 ui_test_utils::SendToOmniboxAndSubmit(location_bar, "should not work"); 952 // This means that submitting won't trigger any action. 953 EXPECT_FALSE(model->CurrentMatch(NULL).destination_url.is_valid()); 954 EXPECT_EQ(GURL(url::kAboutBlankURL), web_contents->GetURL()); 955 } 956 957 IN_PROC_BROWSER_TEST_F(PolicyTest, PolicyPreprocessing) { 958 // Add an individual proxy policy value. 959 PolicyMap policies; 960 policies.Set(key::kProxyServerMode, 961 POLICY_LEVEL_MANDATORY, 962 POLICY_SCOPE_USER, 963 base::Value::CreateIntegerValue(3), 964 NULL); 965 UpdateProviderPolicy(policies); 966 967 // It should be removed and replaced with a dictionary. 968 PolicyMap expected; 969 scoped_ptr<base::DictionaryValue> expected_value(new base::DictionaryValue); 970 expected_value->SetInteger(key::kProxyServerMode, 3); 971 expected.Set(key::kProxySettings, 972 POLICY_LEVEL_MANDATORY, 973 POLICY_SCOPE_USER, 974 expected_value.release(), 975 NULL); 976 977 // Check both the browser and the profile. 978 const PolicyMap& actual_from_browser = 979 g_browser_process->browser_policy_connector() 980 ->GetPolicyService() 981 ->GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())); 982 EXPECT_TRUE(expected.Equals(actual_from_browser)); 983 const PolicyMap& actual_from_profile = 984 ProfilePolicyConnectorFactory::GetForProfile(browser()->profile()) 985 ->policy_service() 986 ->GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())); 987 EXPECT_TRUE(expected.Equals(actual_from_profile)); 988 } 989 990 IN_PROC_BROWSER_TEST_F(PolicyTest, ForceSafeSearch) { 991 // Makes the requests fail since all we want to check is that the redirection 992 // is done properly. 993 MakeRequestFail make_request_fail("google.com"); 994 995 // Verifies that requests to Google Search engine with the SafeSearch 996 // enabled set the safe=active&ssui=on parameters at the end of the query. 997 TemplateURLService* service = TemplateURLServiceFactory::GetForProfile( 998 browser()->profile()); 999 ui_test_utils::WaitForTemplateURLServiceToLoad(service); 1000 1001 // First check that nothing happens. 1002 content::TestNavigationObserver no_safesearch_observer( 1003 browser()->tab_strip_model()->GetActiveWebContents()); 1004 chrome::FocusLocationBar(browser()); 1005 LocationBar* location_bar = browser()->window()->GetLocationBar(); 1006 ui_test_utils::SendToOmniboxAndSubmit(location_bar, "http://google.com/"); 1007 OmniboxEditModel* model = location_bar->GetOmniboxView()->model(); 1008 no_safesearch_observer.Wait(); 1009 EXPECT_TRUE(model->CurrentMatch(NULL).destination_url.is_valid()); 1010 content::WebContents* web_contents = 1011 browser()->tab_strip_model()->GetActiveWebContents(); 1012 GURL expected_without("http://google.com/"); 1013 EXPECT_EQ(expected_without, web_contents->GetURL()); 1014 1015 PrefService* prefs = browser()->profile()->GetPrefs(); 1016 EXPECT_FALSE(prefs->IsManagedPreference(prefs::kForceSafeSearch)); 1017 EXPECT_FALSE(prefs->GetBoolean(prefs::kForceSafeSearch)); 1018 1019 // Override the default SafeSearch setting using policies. 1020 PolicyMap policies; 1021 policies.Set(key::kForceSafeSearch, POLICY_LEVEL_MANDATORY, 1022 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1023 UpdateProviderPolicy(policies); 1024 1025 EXPECT_TRUE(prefs->IsManagedPreference(prefs::kForceSafeSearch)); 1026 EXPECT_TRUE(prefs->GetBoolean(prefs::kForceSafeSearch)); 1027 1028 content::TestNavigationObserver safesearch_observer( 1029 browser()->tab_strip_model()->GetActiveWebContents()); 1030 1031 // Verify that searching from google.com works. 1032 chrome::FocusLocationBar(browser()); 1033 ui_test_utils::SendToOmniboxAndSubmit(location_bar, "http://google.com/"); 1034 safesearch_observer.Wait(); 1035 EXPECT_TRUE(model->CurrentMatch(NULL).destination_url.is_valid()); 1036 web_contents = browser()->tab_strip_model()->GetActiveWebContents(); 1037 std::string expected_url("http://google.com/?"); 1038 expected_url += std::string(chrome::kSafeSearchSafeParameter) + "&" + 1039 chrome::kSafeSearchSsuiParameter; 1040 GURL expected_with_parameters(expected_url); 1041 EXPECT_EQ(expected_with_parameters, web_contents->GetURL()); 1042 } 1043 1044 IN_PROC_BROWSER_TEST_F(PolicyTest, ReplaceSearchTerms) { 1045 MakeRequestFail make_request_fail("search.example"); 1046 1047 chrome::EnableQueryExtractionForTesting(); 1048 1049 // Verifies that a default search is made using the provider configured via 1050 // policy. Also checks that default search can be completely disabled. 1051 const base::string16 kKeyword(base::ASCIIToUTF16("testsearch")); 1052 const std::string kSearchURL("https://www.google.com/search?q={searchTerms}"); 1053 const std::string kInstantURL("http://does/not/exist"); 1054 const std::string kAlternateURL0( 1055 "https://www.google.com/search#q={searchTerms}"); 1056 const std::string kAlternateURL1("https://www.google.com/#q={searchTerms}"); 1057 const std::string kSearchTermsReplacementKey( 1058 "{google:instantExtendedEnabledKey}"); 1059 1060 TemplateURLService* service = TemplateURLServiceFactory::GetForProfile( 1061 browser()->profile()); 1062 ui_test_utils::WaitForTemplateURLServiceToLoad(service); 1063 TemplateURL* default_search = service->GetDefaultSearchProvider(); 1064 ASSERT_TRUE(default_search); 1065 EXPECT_NE(kKeyword, default_search->keyword()); 1066 EXPECT_NE(kSearchURL, default_search->url()); 1067 EXPECT_NE(kInstantURL, default_search->instant_url()); 1068 EXPECT_FALSE( 1069 default_search->alternate_urls().size() == 2 && 1070 default_search->alternate_urls()[0] == kAlternateURL0 && 1071 default_search->alternate_urls()[1] == kAlternateURL1); 1072 1073 // Override the default search provider using policies. 1074 PolicyMap policies; 1075 policies.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY, 1076 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1077 policies.Set(key::kDefaultSearchProviderKeyword, 1078 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 1079 base::Value::CreateStringValue(kKeyword), NULL); 1080 policies.Set(key::kDefaultSearchProviderSearchURL, 1081 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 1082 base::Value::CreateStringValue(kSearchURL), NULL); 1083 policies.Set(key::kDefaultSearchProviderInstantURL, 1084 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 1085 base::Value::CreateStringValue(kInstantURL), NULL); 1086 base::ListValue* alternate_urls = new base::ListValue(); 1087 alternate_urls->AppendString(kAlternateURL0); 1088 alternate_urls->AppendString(kAlternateURL1); 1089 policies.Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY, 1090 POLICY_SCOPE_USER, alternate_urls, NULL); 1091 policies.Set(key::kDefaultSearchProviderSearchTermsReplacementKey, 1092 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 1093 base::Value::CreateStringValue(kSearchTermsReplacementKey), 1094 NULL); 1095 UpdateProviderPolicy(policies); 1096 default_search = service->GetDefaultSearchProvider(); 1097 ASSERT_TRUE(default_search); 1098 EXPECT_EQ(kKeyword, default_search->keyword()); 1099 EXPECT_EQ(kSearchURL, default_search->url()); 1100 EXPECT_EQ(kInstantURL, default_search->instant_url()); 1101 EXPECT_EQ(2U, default_search->alternate_urls().size()); 1102 EXPECT_EQ(kAlternateURL0, default_search->alternate_urls()[0]); 1103 EXPECT_EQ(kAlternateURL1, default_search->alternate_urls()[1]); 1104 1105 // Query terms replacement requires that the renderer process be a recognized 1106 // Instant renderer. Fake it. 1107 InstantService* instant_service = 1108 InstantServiceFactory::GetForProfile(browser()->profile()); 1109 instant_service->AddInstantProcess(browser()->tab_strip_model()-> 1110 GetActiveWebContents()->GetRenderProcessHost()->GetID()); 1111 1112 // Verify that searching from the omnibox does search term replacement with 1113 // first URL pattern. 1114 chrome::FocusLocationBar(browser()); 1115 LocationBar* location_bar = browser()->window()->GetLocationBar(); 1116 OmniboxView* omnibox_view = location_bar->GetOmniboxView(); 1117 ui_test_utils::SendToOmniboxAndSubmit(location_bar, 1118 "https://www.google.com/?espv=1#q=foobar"); 1119 EXPECT_TRUE( 1120 browser()->toolbar_model()->WouldPerformSearchTermReplacement(false)); 1121 EXPECT_EQ(base::ASCIIToUTF16("foobar"), omnibox_view->GetText()); 1122 1123 // Verify that not using espv=1 does not do search term replacement. 1124 chrome::FocusLocationBar(browser()); 1125 ui_test_utils::SendToOmniboxAndSubmit(location_bar, 1126 "https://www.google.com/?q=foobar"); 1127 EXPECT_FALSE( 1128 browser()->toolbar_model()->WouldPerformSearchTermReplacement(false)); 1129 EXPECT_EQ(base::ASCIIToUTF16("https://www.google.com/?q=foobar"), 1130 omnibox_view->GetText()); 1131 1132 // Verify that searching from the omnibox does search term replacement with 1133 // second URL pattern. 1134 chrome::FocusLocationBar(browser()); 1135 ui_test_utils::SendToOmniboxAndSubmit(location_bar, 1136 "https://www.google.com/search?espv=1#q=banana"); 1137 EXPECT_TRUE( 1138 browser()->toolbar_model()->WouldPerformSearchTermReplacement(false)); 1139 EXPECT_EQ(base::ASCIIToUTF16("banana"), omnibox_view->GetText()); 1140 1141 // Verify that searching from the omnibox does search term replacement with 1142 // standard search URL pattern. 1143 chrome::FocusLocationBar(browser()); 1144 ui_test_utils::SendToOmniboxAndSubmit(location_bar, 1145 "https://www.google.com/search?q=tractor+parts&espv=1"); 1146 EXPECT_TRUE( 1147 browser()->toolbar_model()->WouldPerformSearchTermReplacement(false)); 1148 EXPECT_EQ(base::ASCIIToUTF16("tractor parts"), omnibox_view->GetText()); 1149 1150 // Verify that searching from the omnibox prioritizes hash over query. 1151 chrome::FocusLocationBar(browser()); 1152 ui_test_utils::SendToOmniboxAndSubmit(location_bar, 1153 "https://www.google.com/search?q=tractor+parts&espv=1#q=foobar"); 1154 EXPECT_TRUE( 1155 browser()->toolbar_model()->WouldPerformSearchTermReplacement(false)); 1156 EXPECT_EQ(base::ASCIIToUTF16("foobar"), omnibox_view->GetText()); 1157 } 1158 1159 IN_PROC_BROWSER_TEST_F(PolicyTest, Disable3DAPIs) { 1160 // This test assumes Gpu access. 1161 if (!content::GpuDataManager::GetInstance()->GpuAccessAllowed(NULL)) 1162 return; 1163 1164 ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL)); 1165 // WebGL is enabled by default. 1166 content::WebContents* contents = 1167 browser()->tab_strip_model()->GetActiveWebContents(); 1168 EXPECT_TRUE(IsWebGLEnabled(contents)); 1169 // Disable with a policy. 1170 PolicyMap policies; 1171 policies.Set(key::kDisable3DAPIs, POLICY_LEVEL_MANDATORY, 1172 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1173 UpdateProviderPolicy(policies); 1174 // Crash and reload the tab to get a new renderer. 1175 content::CrashTab(contents); 1176 EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_RELOAD)); 1177 EXPECT_FALSE(IsWebGLEnabled(contents)); 1178 // Enable with a policy. 1179 policies.Set(key::kDisable3DAPIs, POLICY_LEVEL_MANDATORY, 1180 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 1181 UpdateProviderPolicy(policies); 1182 content::CrashTab(contents); 1183 EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_RELOAD)); 1184 EXPECT_TRUE(IsWebGLEnabled(contents)); 1185 } 1186 1187 IN_PROC_BROWSER_TEST_F(PolicyTest, DisableSpdy) { 1188 // Verifies that SPDY can be disable by policy. 1189 EXPECT_TRUE(net::HttpStreamFactory::spdy_enabled()); 1190 PolicyMap policies; 1191 policies.Set(key::kDisableSpdy, POLICY_LEVEL_MANDATORY, 1192 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1193 UpdateProviderPolicy(policies); 1194 content::RunAllPendingInMessageLoop(); 1195 EXPECT_FALSE(net::HttpStreamFactory::spdy_enabled()); 1196 // Verify that it can be force-enabled too. 1197 browser()->profile()->GetPrefs()->SetBoolean(prefs::kDisableSpdy, true); 1198 policies.Set(key::kDisableSpdy, POLICY_LEVEL_MANDATORY, 1199 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 1200 UpdateProviderPolicy(policies); 1201 content::RunAllPendingInMessageLoop(); 1202 EXPECT_TRUE(net::HttpStreamFactory::spdy_enabled()); 1203 } 1204 1205 IN_PROC_BROWSER_TEST_F(PolicyTest, DisabledPlugins) { 1206 // Verifies that plugins can be forced to be disabled by policy. 1207 1208 // Verify that the Flash plugin exists and that it can be enabled and disabled 1209 // by the user. 1210 std::vector<content::WebPluginInfo> plugins; 1211 GetPluginList(&plugins); 1212 const content::WebPluginInfo* flash = GetFlashPlugin(plugins); 1213 if (!flash) 1214 return; 1215 PluginPrefs* plugin_prefs = 1216 PluginPrefs::GetForProfile(browser()->profile()).get(); 1217 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1218 EXPECT_TRUE(SetPluginEnabled(plugin_prefs, flash, false)); 1219 EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash)); 1220 EXPECT_TRUE(SetPluginEnabled(plugin_prefs, flash, true)); 1221 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1222 1223 // Now disable it with a policy. 1224 base::ListValue disabled_plugins; 1225 disabled_plugins.Append(base::Value::CreateStringValue("*Flash*")); 1226 PolicyMap policies; 1227 policies.Set(key::kDisabledPlugins, POLICY_LEVEL_MANDATORY, 1228 POLICY_SCOPE_USER, disabled_plugins.DeepCopy(), NULL); 1229 UpdateProviderPolicy(policies); 1230 EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash)); 1231 // The user shouldn't be able to enable it. 1232 EXPECT_FALSE(SetPluginEnabled(plugin_prefs, flash, true)); 1233 EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash)); 1234 } 1235 1236 IN_PROC_BROWSER_TEST_F(PolicyTest, DisabledPluginsExceptions) { 1237 // Verifies that plugins with an exception in the blacklist can be enabled. 1238 1239 // Verify that the Flash plugin exists and that it can be enabled and disabled 1240 // by the user. 1241 std::vector<content::WebPluginInfo> plugins; 1242 GetPluginList(&plugins); 1243 const content::WebPluginInfo* flash = GetFlashPlugin(plugins); 1244 if (!flash) 1245 return; 1246 PluginPrefs* plugin_prefs = 1247 PluginPrefs::GetForProfile(browser()->profile()).get(); 1248 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1249 1250 // Disable all plugins. 1251 base::ListValue disabled_plugins; 1252 disabled_plugins.Append(base::Value::CreateStringValue("*")); 1253 PolicyMap policies; 1254 policies.Set(key::kDisabledPlugins, POLICY_LEVEL_MANDATORY, 1255 POLICY_SCOPE_USER, disabled_plugins.DeepCopy(), NULL); 1256 UpdateProviderPolicy(policies); 1257 EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash)); 1258 // The user shouldn't be able to enable it. 1259 EXPECT_FALSE(SetPluginEnabled(plugin_prefs, flash, true)); 1260 EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash)); 1261 1262 // Now open an exception for flash. 1263 base::ListValue disabled_plugins_exceptions; 1264 disabled_plugins_exceptions.Append( 1265 base::Value::CreateStringValue("*Flash*")); 1266 policies.Set(key::kDisabledPluginsExceptions, POLICY_LEVEL_MANDATORY, 1267 POLICY_SCOPE_USER, disabled_plugins_exceptions.DeepCopy(), NULL); 1268 UpdateProviderPolicy(policies); 1269 // It should revert to the user's preference automatically. 1270 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1271 // And the user should be able to disable and enable again. 1272 EXPECT_TRUE(SetPluginEnabled(plugin_prefs, flash, false)); 1273 EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash)); 1274 EXPECT_TRUE(SetPluginEnabled(plugin_prefs, flash, true)); 1275 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1276 } 1277 1278 IN_PROC_BROWSER_TEST_F(PolicyTest, EnabledPlugins) { 1279 // Verifies that a plugin can be force-installed with a policy. 1280 std::vector<content::WebPluginInfo> plugins; 1281 GetPluginList(&plugins); 1282 const content::WebPluginInfo* flash = GetFlashPlugin(plugins); 1283 if (!flash) 1284 return; 1285 PluginPrefs* plugin_prefs = 1286 PluginPrefs::GetForProfile(browser()->profile()).get(); 1287 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1288 1289 // The user disables it and then a policy forces it to be enabled. 1290 EXPECT_TRUE(SetPluginEnabled(plugin_prefs, flash, false)); 1291 EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash)); 1292 base::ListValue plugin_list; 1293 plugin_list.Append(base::Value::CreateStringValue(content::kFlashPluginName)); 1294 PolicyMap policies; 1295 policies.Set(key::kEnabledPlugins, POLICY_LEVEL_MANDATORY, 1296 POLICY_SCOPE_USER, plugin_list.DeepCopy(), NULL); 1297 UpdateProviderPolicy(policies); 1298 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1299 // The user can't disable it anymore. 1300 EXPECT_FALSE(SetPluginEnabled(plugin_prefs, flash, false)); 1301 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1302 1303 // When a plugin is both enabled and disabled, the whitelist takes precedence. 1304 policies.Set(key::kDisabledPlugins, POLICY_LEVEL_MANDATORY, 1305 POLICY_SCOPE_USER, plugin_list.DeepCopy(), NULL); 1306 UpdateProviderPolicy(policies); 1307 EXPECT_TRUE(plugin_prefs->IsPluginEnabled(*flash)); 1308 } 1309 1310 IN_PROC_BROWSER_TEST_F(PolicyTest, AlwaysAuthorizePlugins) { 1311 // Verifies that dangerous plugins can be always authorized to run with 1312 // a policy. 1313 1314 // Verify that the test page exists. It is only present in checkouts with 1315 // src-internal. 1316 if (!base::PathExists(ui_test_utils::GetTestFilePath( 1317 base::FilePath(FILE_PATH_LITERAL("plugin")), 1318 base::FilePath(FILE_PATH_LITERAL("quicktime.html"))))) { 1319 LOG(INFO) << 1320 "Test skipped because plugin/quicktime.html test file wasn't found."; 1321 return; 1322 } 1323 1324 ServeContentTestData(); 1325 // No plugins at startup. 1326 EXPECT_EQ(0, CountPlugins()); 1327 1328 content::WebContents* contents = 1329 browser()->tab_strip_model()->GetActiveWebContents(); 1330 ASSERT_TRUE(contents); 1331 InfoBarService* infobar_service = InfoBarService::FromWebContents(contents); 1332 ASSERT_TRUE(infobar_service); 1333 EXPECT_EQ(0u, infobar_service->infobar_count()); 1334 1335 base::FilePath path(FILE_PATH_LITERAL("plugin/quicktime.html")); 1336 GURL url(URLRequestMockHTTPJob::GetMockUrl(path)); 1337 ui_test_utils::NavigateToURL(browser(), url); 1338 // This should have triggered the dangerous plugin infobar. 1339 ASSERT_EQ(1u, infobar_service->infobar_count()); 1340 EXPECT_TRUE( 1341 infobar_service->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate()); 1342 // And the plugin isn't running. 1343 EXPECT_EQ(0, CountPlugins()); 1344 1345 // Now set a policy to always authorize this. 1346 PolicyMap policies; 1347 policies.Set(key::kAlwaysAuthorizePlugins, POLICY_LEVEL_MANDATORY, 1348 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1349 UpdateProviderPolicy(policies); 1350 // Reloading the page shouldn't trigger the infobar this time. 1351 ui_test_utils::NavigateToURL(browser(), url); 1352 EXPECT_EQ(0u, infobar_service->infobar_count()); 1353 // And the plugin started automatically. 1354 EXPECT_EQ(1, CountPlugins()); 1355 } 1356 1357 IN_PROC_BROWSER_TEST_F(PolicyTest, DeveloperToolsDisabled) { 1358 // Verifies that access to the developer tools can be disabled. 1359 1360 // Open devtools. 1361 EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_DEV_TOOLS)); 1362 content::WebContents* contents = 1363 browser()->tab_strip_model()->GetActiveWebContents(); 1364 DevToolsWindow *devtools_window = 1365 DevToolsWindow::GetInstanceForInspectedRenderViewHost( 1366 contents->GetRenderViewHost()); 1367 EXPECT_TRUE(devtools_window); 1368 1369 // Disable devtools via policy. 1370 PolicyMap policies; 1371 policies.Set(key::kDeveloperToolsDisabled, POLICY_LEVEL_MANDATORY, 1372 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1373 content::WindowedNotificationObserver close_observer( 1374 content::NOTIFICATION_WEB_CONTENTS_DESTROYED, 1375 content::Source<content::WebContents>( 1376 devtools_window->web_contents_for_test())); 1377 UpdateProviderPolicy(policies); 1378 // wait for devtools close 1379 close_observer.Wait(); 1380 // The existing devtools window should have closed. 1381 EXPECT_FALSE(DevToolsWindow::GetInstanceForInspectedRenderViewHost( 1382 contents->GetRenderViewHost())); 1383 // And it's not possible to open it again. 1384 EXPECT_FALSE(chrome::ExecuteCommand(browser(), IDC_DEV_TOOLS)); 1385 EXPECT_FALSE(DevToolsWindow::GetInstanceForInspectedRenderViewHost( 1386 contents->GetRenderViewHost())); 1387 } 1388 1389 // TODO(samarth): remove along with rest of NTP4 code. 1390 IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_WebStoreIconHidden) { 1391 #if defined(OS_WIN) && defined(USE_ASH) 1392 // Disable this test in Metro+Ash for now (http://crbug.com/262796). 1393 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests)) 1394 return; 1395 #endif 1396 1397 // Verifies that the web store icons can be hidden from the new tab page. 1398 1399 // Open new tab page and look for the web store icons. 1400 ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL)); 1401 content::WebContents* contents = 1402 browser()->tab_strip_model()->GetActiveWebContents(); 1403 1404 #if !defined(OS_CHROMEOS) 1405 // Look for web store's app ID in the apps page. 1406 EXPECT_TRUE(ContainsVisibleElement(contents, 1407 "ahfgeienlihckogmohjhadlkjgocpleb")); 1408 #endif 1409 1410 // The next NTP has no footer. 1411 if (ContainsVisibleElement(contents, "footer")) 1412 EXPECT_TRUE(ContainsVisibleElement(contents, "chrome-web-store-link")); 1413 1414 // Turn off the web store icons. 1415 PolicyMap policies; 1416 policies.Set(key::kHideWebStoreIcon, POLICY_LEVEL_MANDATORY, 1417 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1418 UpdateProviderPolicy(policies); 1419 1420 // The web store icons should now be hidden. 1421 ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL)); 1422 EXPECT_FALSE(ContainsVisibleElement(contents, 1423 "ahfgeienlihckogmohjhadlkjgocpleb")); 1424 EXPECT_FALSE(ContainsVisibleElement(contents, "chrome-web-store-link")); 1425 } 1426 1427 IN_PROC_BROWSER_TEST_F(PolicyTest, DownloadDirectory) { 1428 // Verifies that the download directory can be forced by policy. 1429 1430 // Set the initial download directory. 1431 base::ScopedTempDir initial_dir; 1432 ASSERT_TRUE(initial_dir.CreateUniqueTempDir()); 1433 browser()->profile()->GetPrefs()->SetFilePath( 1434 prefs::kDownloadDefaultDirectory, initial_dir.path()); 1435 // Don't prompt for the download location during this test. 1436 browser()->profile()->GetPrefs()->SetBoolean( 1437 prefs::kPromptForDownload, false); 1438 1439 // Verify that downloads end up on the default directory. 1440 base::FilePath file(FILE_PATH_LITERAL("download-test1.lib")); 1441 DownloadAndVerifyFile(browser(), initial_dir.path(), file); 1442 base::DieFileDie(initial_dir.path().Append(file), false); 1443 1444 // Override the download directory with the policy and verify a download. 1445 base::ScopedTempDir forced_dir; 1446 ASSERT_TRUE(forced_dir.CreateUniqueTempDir()); 1447 PolicyMap policies; 1448 policies.Set(key::kDownloadDirectory, POLICY_LEVEL_MANDATORY, 1449 POLICY_SCOPE_USER, 1450 base::Value::CreateStringValue(forced_dir.path().value()), NULL); 1451 UpdateProviderPolicy(policies); 1452 DownloadAndVerifyFile(browser(), forced_dir.path(), file); 1453 // Verify that the first download location wasn't affected. 1454 EXPECT_FALSE(base::PathExists(initial_dir.path().Append(file))); 1455 } 1456 1457 IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionInstallBlacklistSelective) { 1458 // Verifies that blacklisted extensions can't be installed. 1459 ExtensionService* service = extension_service(); 1460 ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1461 ASSERT_FALSE(service->GetExtensionById(kAdBlockCrxId, true)); 1462 base::ListValue blacklist; 1463 blacklist.Append(base::Value::CreateStringValue(kGoodCrxId)); 1464 PolicyMap policies; 1465 policies.Set(key::kExtensionInstallBlacklist, POLICY_LEVEL_MANDATORY, 1466 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 1467 UpdateProviderPolicy(policies); 1468 1469 // "good.crx" is blacklisted. 1470 EXPECT_FALSE(InstallExtension(kGoodCrxName)); 1471 EXPECT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1472 1473 // "adblock.crx" is not. 1474 const extensions::Extension* adblock = InstallExtension(kAdBlockCrxName); 1475 ASSERT_TRUE(adblock); 1476 EXPECT_EQ(kAdBlockCrxId, adblock->id()); 1477 EXPECT_EQ(adblock, 1478 service->GetExtensionById(kAdBlockCrxId, true)); 1479 } 1480 1481 // Flaky on windows; http://crbug.com/307994. 1482 #if defined(OS_WIN) 1483 #define MAYBE_ExtensionInstallBlacklistWildcard DISABLED_ExtensionInstallBlacklistWildcard 1484 #else 1485 #define MAYBE_ExtensionInstallBlacklistWildcard ExtensionInstallBlacklistWildcard 1486 #endif 1487 IN_PROC_BROWSER_TEST_F(PolicyTest, MAYBE_ExtensionInstallBlacklistWildcard) { 1488 // Verify that a wildcard blacklist takes effect. 1489 EXPECT_TRUE(InstallExtension(kAdBlockCrxName)); 1490 ExtensionService* service = extension_service(); 1491 ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1492 ASSERT_TRUE(service->GetExtensionById(kAdBlockCrxId, true)); 1493 base::ListValue blacklist; 1494 blacklist.Append(base::Value::CreateStringValue("*")); 1495 PolicyMap policies; 1496 policies.Set(key::kExtensionInstallBlacklist, POLICY_LEVEL_MANDATORY, 1497 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 1498 UpdateProviderPolicy(policies); 1499 1500 // AdBlock was automatically removed. 1501 ASSERT_FALSE(service->GetExtensionById(kAdBlockCrxId, true)); 1502 1503 // And can't be installed again, nor can good.crx. 1504 EXPECT_FALSE(InstallExtension(kAdBlockCrxName)); 1505 EXPECT_FALSE(service->GetExtensionById(kAdBlockCrxId, true)); 1506 EXPECT_FALSE(InstallExtension(kGoodCrxName)); 1507 EXPECT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1508 } 1509 1510 IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionInstallWhitelist) { 1511 // Verifies that the whitelist can open exceptions to the blacklist. 1512 ExtensionService* service = extension_service(); 1513 ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1514 ASSERT_FALSE(service->GetExtensionById(kAdBlockCrxId, true)); 1515 base::ListValue blacklist; 1516 blacklist.Append(base::Value::CreateStringValue("*")); 1517 base::ListValue whitelist; 1518 whitelist.Append(base::Value::CreateStringValue(kGoodCrxId)); 1519 PolicyMap policies; 1520 policies.Set(key::kExtensionInstallBlacklist, POLICY_LEVEL_MANDATORY, 1521 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 1522 policies.Set(key::kExtensionInstallWhitelist, POLICY_LEVEL_MANDATORY, 1523 POLICY_SCOPE_USER, whitelist.DeepCopy(), NULL); 1524 UpdateProviderPolicy(policies); 1525 // "adblock.crx" is blacklisted. 1526 EXPECT_FALSE(InstallExtension(kAdBlockCrxName)); 1527 EXPECT_FALSE(service->GetExtensionById(kAdBlockCrxId, true)); 1528 // "good.crx" has a whitelist exception. 1529 const extensions::Extension* good = InstallExtension(kGoodCrxName); 1530 ASSERT_TRUE(good); 1531 EXPECT_EQ(kGoodCrxId, good->id()); 1532 EXPECT_EQ(good, service->GetExtensionById(kGoodCrxId, true)); 1533 // The user can also remove this extension. 1534 UninstallExtension(kGoodCrxId, true); 1535 } 1536 1537 IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionInstallForcelist) { 1538 // Verifies that extensions that are force-installed by policies are 1539 // installed and can't be uninstalled. 1540 ExtensionService* service = extension_service(); 1541 ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1542 1543 // Extensions that are force-installed come from an update URL, which defaults 1544 // to the webstore. Use a mock URL for this test with an update manifest 1545 // that includes "good_v1.crx". 1546 base::FilePath path = 1547 base::FilePath(kTestExtensionsDir).Append(kGoodV1CrxManifestName); 1548 GURL url(URLRequestMockHTTPJob::GetMockUrl(path)); 1549 1550 // Setting the forcelist extension should install "good_v1.crx". 1551 base::ListValue forcelist; 1552 forcelist.Append(base::Value::CreateStringValue(base::StringPrintf( 1553 "%s;%s", kGoodCrxId, url.spec().c_str()))); 1554 PolicyMap policies; 1555 policies.Set(key::kExtensionInstallForcelist, POLICY_LEVEL_MANDATORY, 1556 POLICY_SCOPE_USER, forcelist.DeepCopy(), NULL); 1557 content::WindowedNotificationObserver observer( 1558 chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED, 1559 content::NotificationService::AllSources()); 1560 UpdateProviderPolicy(policies); 1561 observer.Wait(); 1562 // Note: Cannot check that the notification details match the expected 1563 // exception, since the details object has already been freed prior to 1564 // the completion of observer.Wait(). 1565 1566 EXPECT_TRUE(service->GetExtensionById(kGoodCrxId, true)); 1567 1568 // The user is not allowed to uninstall force-installed extensions. 1569 UninstallExtension(kGoodCrxId, false); 1570 1571 // The user is not allowed to load an unpacked extension with the 1572 // same ID as a force-installed extension. 1573 LoadUnpackedExtension(kGoodUnpackedExt, false); 1574 1575 // Loading other unpacked extensions are not blocked. 1576 LoadUnpackedExtension(kAppUnpackedExt, true); 1577 1578 const std::string old_version_number = 1579 service->GetExtensionById(kGoodCrxId, true)->version()->GetString(); 1580 1581 base::FilePath test_path; 1582 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_path)); 1583 1584 TestRequestInterceptor interceptor( 1585 "update.extension", 1586 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)); 1587 interceptor.PushJobCallback( 1588 TestRequestInterceptor::FileJob( 1589 test_path.Append(kTestExtensionsDir).Append(kGood2CrxManifestName))); 1590 1591 // Updating the force-installed extension. 1592 extensions::ExtensionUpdater* updater = service->updater(); 1593 extensions::ExtensionUpdater::CheckParams params; 1594 params.install_immediately = true; 1595 content::WindowedNotificationObserver update_observer( 1596 chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED, 1597 content::NotificationService::AllSources()); 1598 updater->CheckNow(params); 1599 update_observer.Wait(); 1600 1601 const base::Version* new_version = 1602 service->GetExtensionById(kGoodCrxId, true)->version(); 1603 ASSERT_TRUE(new_version->IsValid()); 1604 base::Version old_version(old_version_number); 1605 ASSERT_TRUE(old_version.IsValid()); 1606 1607 EXPECT_EQ(1, new_version->CompareTo(old_version)); 1608 1609 EXPECT_EQ(0u, interceptor.GetPendingSize()); 1610 1611 // Wait until any background pages belonging to force-installed extensions 1612 // have been loaded. 1613 extensions::ProcessManager* manager = 1614 extensions::ExtensionSystem::Get(browser()->profile())->process_manager(); 1615 extensions::ProcessManager::ViewSet all_views = manager->GetAllViews(); 1616 for (extensions::ProcessManager::ViewSet::const_iterator iter = 1617 all_views.begin(); 1618 iter != all_views.end();) { 1619 if (!(*iter)->IsLoading()) { 1620 ++iter; 1621 } else { 1622 content::WebContents* web_contents = 1623 content::WebContents::FromRenderViewHost(*iter); 1624 ASSERT_TRUE(web_contents); 1625 WebContentsLoadedOrDestroyedWatcher(web_contents).Wait(); 1626 1627 // Test activity may have modified the set of extension processes during 1628 // message processing, so re-start the iteration to catch added/removed 1629 // processes. 1630 all_views = manager->GetAllViews(); 1631 iter = all_views.begin(); 1632 } 1633 } 1634 1635 // Test policy-installed extensions are reloaded when killed. 1636 BackgroundContentsService:: 1637 SetRestartDelayForForceInstalledAppsAndExtensionsForTesting(0); 1638 content::WindowedNotificationObserver extension_crashed_observer( 1639 chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED, 1640 content::NotificationService::AllSources()); 1641 content::WindowedNotificationObserver extension_loaded_observer( 1642 chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED, 1643 content::NotificationService::AllSources()); 1644 extensions::ExtensionHost* extension_host = 1645 extensions::ExtensionSystem::Get(browser()->profile())-> 1646 process_manager()->GetBackgroundHostForExtension(kGoodCrxId); 1647 base::KillProcess(extension_host->render_process_host()->GetHandle(), 1648 content::RESULT_CODE_KILLED, false); 1649 extension_crashed_observer.Wait(); 1650 extension_loaded_observer.Wait(); 1651 } 1652 1653 IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionAllowedTypes) { 1654 // Verifies that extensions are blocked if policy specifies an allowed types 1655 // list and the extension's type is not on that list. 1656 ExtensionService* service = extension_service(); 1657 ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1658 ASSERT_FALSE(service->GetExtensionById(kHostedAppCrxId, true)); 1659 1660 base::ListValue allowed_types; 1661 allowed_types.AppendString("hosted_app"); 1662 PolicyMap policies; 1663 policies.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY, 1664 POLICY_SCOPE_USER, allowed_types.DeepCopy(), NULL); 1665 UpdateProviderPolicy(policies); 1666 1667 // "good.crx" is blocked. 1668 EXPECT_FALSE(InstallExtension(kGoodCrxName)); 1669 EXPECT_FALSE(service->GetExtensionById(kGoodCrxId, true)); 1670 1671 // "hosted_app.crx" is of a whitelisted type. 1672 const extensions::Extension* hosted_app = InstallExtension(kHostedAppCrxName); 1673 ASSERT_TRUE(hosted_app); 1674 EXPECT_EQ(kHostedAppCrxId, hosted_app->id()); 1675 EXPECT_EQ(hosted_app, service->GetExtensionById(kHostedAppCrxId, true)); 1676 1677 // The user can remove the extension. 1678 UninstallExtension(kHostedAppCrxId, true); 1679 } 1680 1681 // Checks that a click on an extension CRX download triggers the extension 1682 // installation prompt without further user interaction when the source is 1683 // whitelisted by policy. 1684 // Flaky on windows; http://crbug.com/295729 . 1685 #if defined(OS_WIN) 1686 #define MAYBE_ExtensionInstallSources DISABLED_ExtensionInstallSources 1687 #else 1688 #define MAYBE_ExtensionInstallSources ExtensionInstallSources 1689 #endif 1690 IN_PROC_BROWSER_TEST_F(PolicyTest, MAYBE_ExtensionInstallSources) { 1691 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 1692 switches::kAppsGalleryInstallAutoConfirmForTests, "accept"); 1693 1694 const GURL install_source_url(URLRequestMockHTTPJob::GetMockUrl( 1695 base::FilePath(FILE_PATH_LITERAL("extensions/*")))); 1696 const GURL referrer_url(URLRequestMockHTTPJob::GetMockUrl( 1697 base::FilePath(FILE_PATH_LITERAL("policy/*")))); 1698 1699 base::ScopedTempDir download_directory; 1700 ASSERT_TRUE(download_directory.CreateUniqueTempDir()); 1701 DownloadPrefs* download_prefs = 1702 DownloadPrefs::FromBrowserContext(browser()->profile()); 1703 download_prefs->SetDownloadPath(download_directory.path()); 1704 1705 const GURL download_page_url(URLRequestMockHTTPJob::GetMockUrl(base::FilePath( 1706 FILE_PATH_LITERAL("policy/extension_install_sources_test.html")))); 1707 ui_test_utils::NavigateToURL(browser(), download_page_url); 1708 1709 // As long as the policy is not present, extensions are considered dangerous. 1710 content::DownloadTestObserverTerminal download_observer( 1711 content::BrowserContext::GetDownloadManager(browser()->profile()), 1, 1712 content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY); 1713 PerformClick(0, 0); 1714 download_observer.WaitForFinished(); 1715 1716 // Install the policy and trigger another download. 1717 base::ListValue install_sources; 1718 install_sources.AppendString(install_source_url.spec()); 1719 install_sources.AppendString(referrer_url.spec()); 1720 PolicyMap policies; 1721 policies.Set(key::kExtensionInstallSources, POLICY_LEVEL_MANDATORY, 1722 POLICY_SCOPE_USER, install_sources.DeepCopy(), NULL); 1723 UpdateProviderPolicy(policies); 1724 1725 content::WindowedNotificationObserver observer( 1726 chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED, 1727 content::NotificationService::AllSources()); 1728 PerformClick(1, 0); 1729 observer.Wait(); 1730 // Note: Cannot check that the notification details match the expected 1731 // exception, since the details object has already been freed prior to 1732 // the completion of observer.Wait(). 1733 1734 // The first extension shouldn't be present, the second should be there. 1735 EXPECT_FALSE(extension_service()->GetExtensionById(kGoodCrxId, true)); 1736 EXPECT_TRUE(extension_service()->GetExtensionById(kAdBlockCrxId, false)); 1737 } 1738 1739 IN_PROC_BROWSER_TEST_F(PolicyTest, HomepageLocation) { 1740 #if defined(OS_WIN) && defined(USE_ASH) 1741 // Disable this test in Metro+Ash for now (http://crbug.com/262796). 1742 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests)) 1743 return; 1744 #endif 1745 1746 // Verifies that the homepage can be configured with policies. 1747 // Set a default, and check that the home button navigates there. 1748 browser()->profile()->GetPrefs()->SetString( 1749 prefs::kHomePage, chrome::kChromeUIPolicyURL); 1750 browser()->profile()->GetPrefs()->SetBoolean( 1751 prefs::kHomePageIsNewTabPage, false); 1752 EXPECT_EQ(GURL(chrome::kChromeUIPolicyURL), 1753 browser()->profile()->GetHomePage()); 1754 content::WebContents* contents = 1755 browser()->tab_strip_model()->GetActiveWebContents(); 1756 EXPECT_EQ(GURL(url::kAboutBlankURL), contents->GetURL()); 1757 EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_HOME)); 1758 EXPECT_EQ(GURL(chrome::kChromeUIPolicyURL), contents->GetURL()); 1759 1760 // Now override with policy. 1761 PolicyMap policies; 1762 policies.Set(key::kHomepageLocation, POLICY_LEVEL_MANDATORY, 1763 POLICY_SCOPE_USER, 1764 base::Value::CreateStringValue(chrome::kChromeUICreditsURL), 1765 NULL); 1766 UpdateProviderPolicy(policies); 1767 EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_HOME)); 1768 content::WaitForLoadStop(contents); 1769 EXPECT_EQ(GURL(chrome::kChromeUICreditsURL), contents->GetURL()); 1770 1771 policies.Set(key::kHomepageIsNewTabPage, POLICY_LEVEL_MANDATORY, 1772 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1773 UpdateProviderPolicy(policies); 1774 EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_HOME)); 1775 content::WaitForLoadStop(contents); 1776 EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), contents->GetURL()); 1777 } 1778 1779 IN_PROC_BROWSER_TEST_F(PolicyTest, IncognitoEnabled) { 1780 // Verifies that incognito windows can't be opened when disabled by policy. 1781 1782 const BrowserList* active_browser_list = 1783 BrowserList::GetInstance(chrome::GetActiveDesktop()); 1784 1785 // Disable incognito via policy and verify that incognito windows can't be 1786 // opened. 1787 EXPECT_EQ(1u, active_browser_list->size()); 1788 EXPECT_FALSE(BrowserList::IsOffTheRecordSessionActive()); 1789 PolicyMap policies; 1790 policies.Set(key::kIncognitoEnabled, POLICY_LEVEL_MANDATORY, 1791 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 1792 UpdateProviderPolicy(policies); 1793 EXPECT_FALSE(chrome::ExecuteCommand(browser(), IDC_NEW_INCOGNITO_WINDOW)); 1794 EXPECT_EQ(1u, active_browser_list->size()); 1795 EXPECT_FALSE(BrowserList::IsOffTheRecordSessionActive()); 1796 1797 // Enable via policy and verify that incognito windows can be opened. 1798 policies.Set(key::kIncognitoEnabled, POLICY_LEVEL_MANDATORY, 1799 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1800 UpdateProviderPolicy(policies); 1801 EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_NEW_INCOGNITO_WINDOW)); 1802 EXPECT_EQ(2u, active_browser_list->size()); 1803 EXPECT_TRUE(BrowserList::IsOffTheRecordSessionActive()); 1804 } 1805 1806 IN_PROC_BROWSER_TEST_F(PolicyTest, Javascript) { 1807 // Verifies that Javascript can be disabled. 1808 content::WebContents* contents = 1809 browser()->tab_strip_model()->GetActiveWebContents(); 1810 EXPECT_TRUE(IsJavascriptEnabled(contents)); 1811 EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEV_TOOLS)); 1812 EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEV_TOOLS_CONSOLE)); 1813 EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEV_TOOLS_DEVICES)); 1814 1815 // Disable Javascript via policy. 1816 PolicyMap policies; 1817 policies.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY, 1818 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 1819 UpdateProviderPolicy(policies); 1820 // Reload the page. 1821 ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL)); 1822 EXPECT_FALSE(IsJavascriptEnabled(contents)); 1823 // Developer tools still work when javascript is disabled. 1824 EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEV_TOOLS)); 1825 EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEV_TOOLS_CONSOLE)); 1826 EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEV_TOOLS_DEVICES)); 1827 // Javascript is always enabled for the internal pages. 1828 ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIAboutURL)); 1829 EXPECT_TRUE(IsJavascriptEnabled(contents)); 1830 1831 // The javascript content setting policy overrides the javascript policy. 1832 ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL)); 1833 EXPECT_FALSE(IsJavascriptEnabled(contents)); 1834 policies.Set(key::kDefaultJavaScriptSetting, POLICY_LEVEL_MANDATORY, 1835 POLICY_SCOPE_USER, 1836 base::Value::CreateIntegerValue(CONTENT_SETTING_ALLOW), NULL); 1837 UpdateProviderPolicy(policies); 1838 ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL)); 1839 EXPECT_TRUE(IsJavascriptEnabled(contents)); 1840 } 1841 1842 IN_PROC_BROWSER_TEST_F(PolicyTest, SavingBrowserHistoryDisabled) { 1843 // Verifies that browsing history is not saved. 1844 PolicyMap policies; 1845 policies.Set(key::kSavingBrowserHistoryDisabled, POLICY_LEVEL_MANDATORY, 1846 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1847 UpdateProviderPolicy(policies); 1848 GURL url = ui_test_utils::GetTestUrl( 1849 base::FilePath(base::FilePath::kCurrentDirectory), 1850 base::FilePath(FILE_PATH_LITERAL("empty.html"))); 1851 ui_test_utils::NavigateToURL(browser(), url); 1852 // Verify that the navigation wasn't saved in the history. 1853 ui_test_utils::HistoryEnumerator enumerator1(browser()->profile()); 1854 EXPECT_EQ(0u, enumerator1.urls().size()); 1855 1856 // Now flip the policy and try again. 1857 policies.Set(key::kSavingBrowserHistoryDisabled, POLICY_LEVEL_MANDATORY, 1858 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 1859 UpdateProviderPolicy(policies); 1860 ui_test_utils::NavigateToURL(browser(), url); 1861 // Verify that the navigation was saved in the history. 1862 ui_test_utils::HistoryEnumerator enumerator2(browser()->profile()); 1863 ASSERT_EQ(1u, enumerator2.urls().size()); 1864 EXPECT_EQ(url, enumerator2.urls()[0]); 1865 } 1866 1867 // http://crbug.com/241691 PolicyTest.TranslateEnabled is failing regularly. 1868 IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_TranslateEnabled) { 1869 // TODO(port): Test corresponding bubble translate UX: http://crbug.com/383235 1870 if (TranslateService::IsTranslateBubbleEnabled()) 1871 return; 1872 1873 test::ScopedCLDDynamicDataHarness dynamic_data_scope; 1874 ASSERT_NO_FATAL_FAILURE(dynamic_data_scope.Init()); 1875 1876 // Verifies that translate can be forced enabled or disabled by policy. 1877 1878 // Get the InfoBarService, and verify that there are no infobars on startup. 1879 content::WebContents* contents = 1880 browser()->tab_strip_model()->GetActiveWebContents(); 1881 ASSERT_TRUE(contents); 1882 InfoBarService* infobar_service = InfoBarService::FromWebContents(contents); 1883 ASSERT_TRUE(infobar_service); 1884 EXPECT_EQ(0u, infobar_service->infobar_count()); 1885 1886 // Force enable the translate feature. 1887 PolicyMap policies; 1888 policies.Set(key::kTranslateEnabled, POLICY_LEVEL_MANDATORY, 1889 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 1890 UpdateProviderPolicy(policies); 1891 // Instead of waiting for NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED, this test 1892 // waits for NOTIFICATION_TAB_LANGUAGE_DETERMINED because that's what the 1893 // TranslateManager observes. This allows checking that an infobar is NOT 1894 // shown below, without polling for infobars for some indeterminate amount 1895 // of time. 1896 GURL url = ui_test_utils::GetTestUrl( 1897 base::FilePath(), 1898 base::FilePath(FILE_PATH_LITERAL("translate/fr_test.html"))); 1899 content::WindowedNotificationObserver language_observer1( 1900 chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED, 1901 content::NotificationService::AllSources()); 1902 ui_test_utils::NavigateToURL(browser(), url); 1903 language_observer1.Wait(); 1904 1905 // Verify the translation detected for this tab. 1906 ChromeTranslateClient* chrome_translate_client = 1907 ChromeTranslateClient::FromWebContents(contents); 1908 ASSERT_TRUE(chrome_translate_client); 1909 LanguageState& language_state = chrome_translate_client->GetLanguageState(); 1910 EXPECT_EQ("fr", language_state.original_language()); 1911 EXPECT_TRUE(language_state.page_needs_translation()); 1912 EXPECT_FALSE(language_state.translation_pending()); 1913 EXPECT_FALSE(language_state.translation_declined()); 1914 EXPECT_FALSE(language_state.IsPageTranslated()); 1915 1916 // Verify that the translate infobar showed up. 1917 ASSERT_EQ(1u, infobar_service->infobar_count()); 1918 infobars::InfoBar* infobar = infobar_service->infobar_at(0); 1919 TranslateInfoBarDelegate* translate_infobar_delegate = 1920 infobar->delegate()->AsTranslateInfoBarDelegate(); 1921 ASSERT_TRUE(translate_infobar_delegate); 1922 EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE, 1923 translate_infobar_delegate->translate_step()); 1924 EXPECT_EQ("fr", translate_infobar_delegate->original_language_code()); 1925 1926 // Now force disable translate. 1927 infobar_service->RemoveInfoBar(infobar); 1928 EXPECT_EQ(0u, infobar_service->infobar_count()); 1929 policies.Set(key::kTranslateEnabled, POLICY_LEVEL_MANDATORY, 1930 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 1931 UpdateProviderPolicy(policies); 1932 // Navigating to the same URL now doesn't trigger an infobar. 1933 content::WindowedNotificationObserver language_observer2( 1934 chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED, 1935 content::NotificationService::AllSources()); 1936 ui_test_utils::NavigateToURL(browser(), url); 1937 language_observer2.Wait(); 1938 EXPECT_EQ(0u, infobar_service->infobar_count()); 1939 } 1940 1941 IN_PROC_BROWSER_TEST_F(PolicyTest, URLBlacklist) { 1942 // Checks that URLs can be blacklisted, and that exceptions can be made to 1943 // the blacklist. 1944 1945 // Filter |kURLS| on IO thread, so that requests to those hosts end up 1946 // as URLRequestMockHTTPJobs. 1947 const char* kURLS[] = { 1948 "http://aaa.com/empty.html", 1949 "http://bbb.com/empty.html", 1950 "http://sub.bbb.com/empty.html", 1951 "http://bbb.com/policy/blank.html", 1952 }; 1953 { 1954 base::RunLoop loop; 1955 BrowserThread::PostTaskAndReply( 1956 BrowserThread::IO, FROM_HERE, 1957 base::Bind(RedirectHostsToTestData, kURLS, arraysize(kURLS)), 1958 loop.QuitClosure()); 1959 loop.Run(); 1960 } 1961 1962 // Verify that "bbb.com" opens before applying the blacklist. 1963 CheckCanOpenURL(browser(), kURLS[1]); 1964 1965 // Set a blacklist. 1966 base::ListValue blacklist; 1967 blacklist.Append(base::Value::CreateStringValue("bbb.com")); 1968 PolicyMap policies; 1969 policies.Set(key::kURLBlacklist, POLICY_LEVEL_MANDATORY, 1970 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 1971 UpdateProviderPolicy(policies); 1972 FlushBlacklistPolicy(); 1973 // All bbb.com URLs are blocked, and "aaa.com" is still unblocked. 1974 CheckCanOpenURL(browser(), kURLS[0]); 1975 for (size_t i = 1; i < arraysize(kURLS); ++i) 1976 CheckURLIsBlocked(browser(), kURLS[i]); 1977 1978 // Whitelist some sites of bbb.com. 1979 base::ListValue whitelist; 1980 whitelist.Append(base::Value::CreateStringValue("sub.bbb.com")); 1981 whitelist.Append(base::Value::CreateStringValue("bbb.com/policy")); 1982 policies.Set(key::kURLWhitelist, POLICY_LEVEL_MANDATORY, 1983 POLICY_SCOPE_USER, whitelist.DeepCopy(), NULL); 1984 UpdateProviderPolicy(policies); 1985 FlushBlacklistPolicy(); 1986 CheckURLIsBlocked(browser(), kURLS[1]); 1987 CheckCanOpenURL(browser(), kURLS[2]); 1988 CheckCanOpenURL(browser(), kURLS[3]); 1989 1990 { 1991 base::RunLoop loop; 1992 BrowserThread::PostTaskAndReply( 1993 BrowserThread::IO, FROM_HERE, 1994 base::Bind(UndoRedirectHostsToTestData, kURLS, arraysize(kURLS)), 1995 loop.QuitClosure()); 1996 loop.Run(); 1997 } 1998 } 1999 2000 // This test is flaky on all platforms; see http://crbug.com/339240 2001 IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_FileURLBlacklist) { 2002 // Check that FileURLs can be blacklisted and DisabledSchemes works together 2003 // with URLblacklisting and URLwhitelisting. 2004 2005 base::FilePath test_path; 2006 PathService::Get(chrome::DIR_TEST_DATA, &test_path); 2007 const std::string base_path = "file://" + test_path.AsUTF8Unsafe() +"/"; 2008 const std::string folder_path = base_path + "apptest/"; 2009 const std::string file_path1 = base_path + "title1.html"; 2010 const std::string file_path2 = folder_path + "basic.html"; 2011 2012 CheckCanOpenURL(browser(), file_path1.c_str()); 2013 CheckCanOpenURL(browser(), file_path2.c_str()); 2014 2015 // Set a blacklist for all the files. 2016 base::ListValue blacklist; 2017 blacklist.Append(base::Value::CreateStringValue("file://*")); 2018 PolicyMap policies; 2019 policies.Set(key::kURLBlacklist, POLICY_LEVEL_MANDATORY, 2020 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 2021 UpdateProviderPolicy(policies); 2022 FlushBlacklistPolicy(); 2023 2024 CheckURLIsBlocked(browser(), file_path1.c_str()); 2025 CheckURLIsBlocked(browser(), file_path2.c_str()); 2026 2027 // Replace the URLblacklist with disabling the file scheme. 2028 blacklist.Remove(base::StringValue("file://*"), NULL); 2029 policies.Set(key::kURLBlacklist, POLICY_LEVEL_MANDATORY, 2030 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 2031 UpdateProviderPolicy(policies); 2032 FlushBlacklistPolicy(); 2033 2034 PrefService* prefs = browser()->profile()->GetPrefs(); 2035 const base::ListValue* list_url = prefs->GetList(policy_prefs::kUrlBlacklist); 2036 EXPECT_EQ(list_url->Find(base::StringValue("file://*")), 2037 list_url->end()); 2038 2039 base::ListValue disabledscheme; 2040 disabledscheme.Append(base::Value::CreateStringValue("file")); 2041 policies.Set(key::kDisabledSchemes, POLICY_LEVEL_MANDATORY, 2042 POLICY_SCOPE_USER, disabledscheme.DeepCopy(), NULL); 2043 UpdateProviderPolicy(policies); 2044 FlushBlacklistPolicy(); 2045 2046 list_url = prefs->GetList(policy_prefs::kUrlBlacklist); 2047 EXPECT_NE(list_url->Find(base::StringValue("file://*")), 2048 list_url->end()); 2049 2050 // Whitelist one folder and blacklist an another just inside. 2051 base::ListValue whitelist; 2052 whitelist.Append(base::Value::CreateStringValue(base_path)); 2053 policies.Set(key::kURLWhitelist, POLICY_LEVEL_MANDATORY, 2054 POLICY_SCOPE_USER, whitelist.DeepCopy(), NULL); 2055 blacklist.Append(base::Value::CreateStringValue(folder_path)); 2056 policies.Set(key::kURLBlacklist, POLICY_LEVEL_MANDATORY, 2057 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 2058 UpdateProviderPolicy(policies); 2059 FlushBlacklistPolicy(); 2060 2061 CheckCanOpenURL(browser(), file_path1.c_str()); 2062 CheckURLIsBlocked(browser(), file_path2.c_str()); 2063 } 2064 2065 #if !defined(OS_MACOSX) 2066 IN_PROC_BROWSER_TEST_F(PolicyTest, FullscreenAllowedBrowser) { 2067 PolicyMap policies; 2068 policies.Set(key::kFullscreenAllowed, 2069 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2070 base::Value::CreateBooleanValue(false), NULL); 2071 UpdateProviderPolicy(policies); 2072 2073 BrowserWindow* browser_window = browser()->window(); 2074 ASSERT_TRUE(browser_window); 2075 2076 EXPECT_FALSE(browser_window->IsFullscreen()); 2077 chrome::ToggleFullscreenMode(browser()); 2078 EXPECT_FALSE(browser_window->IsFullscreen()); 2079 } 2080 2081 IN_PROC_BROWSER_TEST_F(PolicyTest, FullscreenAllowedApp) { 2082 PolicyMap policies; 2083 policies.Set(key::kFullscreenAllowed, 2084 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2085 base::Value::CreateBooleanValue(false), NULL); 2086 UpdateProviderPolicy(policies); 2087 2088 const extensions::Extension* extension = 2089 LoadUnpackedExtension(kUnpackedFullscreenAppName, true); 2090 ASSERT_TRUE(extension); 2091 2092 // Launch an app that tries to open a fullscreen window. 2093 TestAddAppWindowObserver add_window_observer( 2094 apps::AppWindowRegistry::Get(browser()->profile())); 2095 OpenApplication(AppLaunchParams(browser()->profile(), 2096 extension, 2097 extensions::LAUNCH_CONTAINER_NONE, 2098 NEW_WINDOW)); 2099 apps::AppWindow* window = add_window_observer.WaitForAppWindow(); 2100 ASSERT_TRUE(window); 2101 2102 // Verify that the window is not in fullscreen mode. 2103 EXPECT_FALSE(window->GetBaseWindow()->IsFullscreen()); 2104 2105 // Verify that the window cannot be toggled into fullscreen mode via apps 2106 // APIs. 2107 EXPECT_TRUE(content::ExecuteScript( 2108 window->web_contents(), 2109 "chrome.app.window.current().fullscreen();")); 2110 EXPECT_FALSE(window->GetBaseWindow()->IsFullscreen()); 2111 2112 // Verify that the window cannot be toggled into fullscreen mode from within 2113 // Chrome (e.g., using keyboard accelerators). 2114 window->Fullscreen(); 2115 EXPECT_FALSE(window->GetBaseWindow()->IsFullscreen()); 2116 } 2117 #endif 2118 2119 #if defined(OS_CHROMEOS) 2120 IN_PROC_BROWSER_TEST_F(PolicyTest, DisableScreenshotsFile) { 2121 int screenshot_count = CountScreenshots(); 2122 2123 // Make sure screenshots are counted correctly. 2124 TestScreenshotFile(true); 2125 ASSERT_EQ(CountScreenshots(), screenshot_count + 1); 2126 2127 // Check if trying to take a screenshot fails when disabled by policy. 2128 TestScreenshotFile(false); 2129 ASSERT_EQ(CountScreenshots(), screenshot_count + 1); 2130 } 2131 2132 IN_PROC_BROWSER_TEST_F(PolicyTest, DisableAudioOutput) { 2133 // Set up the mock observer. 2134 chromeos::CrasAudioHandler* audio_handler = chromeos::CrasAudioHandler::Get(); 2135 scoped_ptr<TestAudioObserver> test_observer(new TestAudioObserver); 2136 audio_handler->AddAudioObserver(test_observer.get()); 2137 2138 bool prior_state = audio_handler->IsOutputMuted(); 2139 // Make sure the audio is not muted and then toggle the policy and observe 2140 // if the output mute changed event is fired. 2141 audio_handler->SetOutputMute(false); 2142 EXPECT_FALSE(audio_handler->IsOutputMuted()); 2143 EXPECT_EQ(1, test_observer->output_mute_changed_count()); 2144 PolicyMap policies; 2145 policies.Set(key::kAudioOutputAllowed, POLICY_LEVEL_MANDATORY, 2146 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL); 2147 UpdateProviderPolicy(policies); 2148 EXPECT_TRUE(audio_handler->IsOutputMuted()); 2149 // This should not change the state now and should not trigger output mute 2150 // changed event. 2151 audio_handler->SetOutputMute(false); 2152 EXPECT_TRUE(audio_handler->IsOutputMuted()); 2153 EXPECT_EQ(1, test_observer->output_mute_changed_count()); 2154 2155 // Toggle back and observe if the output mute changed event is fired. 2156 policies.Set(key::kAudioOutputAllowed, POLICY_LEVEL_MANDATORY, 2157 POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL); 2158 UpdateProviderPolicy(policies); 2159 EXPECT_FALSE(audio_handler->IsOutputMuted()); 2160 EXPECT_EQ(1, test_observer->output_mute_changed_count()); 2161 audio_handler->SetOutputMute(true); 2162 EXPECT_TRUE(audio_handler->IsOutputMuted()); 2163 EXPECT_EQ(2, test_observer->output_mute_changed_count()); 2164 // Revert the prior state. 2165 audio_handler->SetOutputMute(prior_state); 2166 audio_handler->RemoveAudioObserver(test_observer.get()); 2167 } 2168 2169 // Disabled, see http://crbug.com/315308. 2170 IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_PRE_SessionLengthLimit) { 2171 // Indicate that the session started 2 hours ago and no user activity has 2172 // occurred yet. 2173 g_browser_process->local_state()->SetInt64( 2174 prefs::kSessionStartTime, 2175 (base::TimeTicks::Now() - base::TimeDelta::FromHours(2)) 2176 .ToInternalValue()); 2177 } 2178 2179 // Disabled, see http://crbug.com/315308. 2180 IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_SessionLengthLimit) { 2181 content::MockNotificationObserver observer; 2182 content::NotificationRegistrar registrar; 2183 registrar.Add(&observer, 2184 chrome::NOTIFICATION_APP_TERMINATING, 2185 content::NotificationService::AllSources()); 2186 2187 // Set the session length limit to 3 hours. Verify that the session is not 2188 // terminated. 2189 EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _)) 2190 .Times(0); 2191 PolicyMap policies; 2192 policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY, 2193 POLICY_SCOPE_USER, 2194 base::Value::CreateIntegerValue(kThreeHoursInMs), 2195 NULL); 2196 UpdateProviderPolicy(policies); 2197 base::RunLoop().RunUntilIdle(); 2198 Mock::VerifyAndClearExpectations(&observer); 2199 2200 // Decrease the session length limit to 1 hour. Verify that the session is 2201 // terminated immediately. 2202 EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _)); 2203 policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY, 2204 POLICY_SCOPE_USER, 2205 base::Value::CreateIntegerValue(kOneHourInMs), 2206 NULL); 2207 UpdateProviderPolicy(policies); 2208 base::RunLoop().RunUntilIdle(); 2209 Mock::VerifyAndClearExpectations(&observer); 2210 } 2211 2212 // Disabled, see http://crbug.com/315308. 2213 IN_PROC_BROWSER_TEST_F(PolicyTest, 2214 DISABLED_PRE_WaitForInitialUserActivityUsatisfied) { 2215 // Indicate that the session started 2 hours ago and no user activity has 2216 // occurred yet. 2217 g_browser_process->local_state()->SetInt64( 2218 prefs::kSessionStartTime, 2219 (base::TimeTicks::Now() - base::TimeDelta::FromHours(2)) 2220 .ToInternalValue()); 2221 } 2222 2223 // Disabled, see http://crbug.com/315308. 2224 IN_PROC_BROWSER_TEST_F(PolicyTest, 2225 DISABLED_WaitForInitialUserActivityUsatisfied) { 2226 content::MockNotificationObserver observer; 2227 content::NotificationRegistrar registrar; 2228 registrar.Add(&observer, 2229 chrome::NOTIFICATION_APP_TERMINATING, 2230 content::NotificationService::AllSources()); 2231 2232 // Require initial user activity. 2233 PolicyMap policies; 2234 policies.Set(key::kWaitForInitialUserActivity, POLICY_LEVEL_MANDATORY, 2235 POLICY_SCOPE_USER, 2236 new base::FundamentalValue(true), 2237 NULL); 2238 UpdateProviderPolicy(policies); 2239 base::RunLoop().RunUntilIdle(); 2240 2241 // Set the session length limit to 1 hour. Verify that the session is not 2242 // terminated. 2243 EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _)) 2244 .Times(0); 2245 policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY, 2246 POLICY_SCOPE_USER, 2247 base::Value::CreateIntegerValue(kOneHourInMs), 2248 NULL); 2249 UpdateProviderPolicy(policies); 2250 base::RunLoop().RunUntilIdle(); 2251 Mock::VerifyAndClearExpectations(&observer); 2252 } 2253 2254 // Disabled, see http://crbug.com/315308. 2255 IN_PROC_BROWSER_TEST_F(PolicyTest, 2256 DISABLED_PRE_WaitForInitialUserActivitySatisfied) { 2257 // Indicate that initial user activity in this session occurred 2 hours ago. 2258 g_browser_process->local_state()->SetInt64( 2259 prefs::kSessionStartTime, 2260 (base::TimeTicks::Now() - base::TimeDelta::FromHours(2)) 2261 .ToInternalValue()); 2262 g_browser_process->local_state()->SetBoolean( 2263 prefs::kSessionUserActivitySeen, 2264 true); 2265 } 2266 2267 // Disabled, see http://crbug.com/315308. 2268 IN_PROC_BROWSER_TEST_F(PolicyTest, 2269 DISABLED_WaitForInitialUserActivitySatisfied) { 2270 content::MockNotificationObserver observer; 2271 content::NotificationRegistrar registrar; 2272 registrar.Add(&observer, 2273 chrome::NOTIFICATION_APP_TERMINATING, 2274 content::NotificationService::AllSources()); 2275 2276 // Require initial user activity and set the session length limit to 3 hours. 2277 // Verify that the session is not terminated. 2278 EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _)) 2279 .Times(0); 2280 PolicyMap policies; 2281 policies.Set(key::kWaitForInitialUserActivity, POLICY_LEVEL_MANDATORY, 2282 POLICY_SCOPE_USER, 2283 new base::FundamentalValue(true), 2284 NULL); 2285 policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY, 2286 POLICY_SCOPE_USER, 2287 base::Value::CreateIntegerValue(kThreeHoursInMs), 2288 NULL); 2289 UpdateProviderPolicy(policies); 2290 base::RunLoop().RunUntilIdle(); 2291 Mock::VerifyAndClearExpectations(&observer); 2292 2293 // Decrease the session length limit to 1 hour. Verify that the session is 2294 // terminated immediately. 2295 EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _)); 2296 policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY, 2297 POLICY_SCOPE_USER, 2298 base::Value::CreateIntegerValue(kOneHourInMs), 2299 NULL); 2300 UpdateProviderPolicy(policies); 2301 base::RunLoop().RunUntilIdle(); 2302 Mock::VerifyAndClearExpectations(&observer); 2303 } 2304 2305 IN_PROC_BROWSER_TEST_F(PolicyTest, LargeCursorEnabled) { 2306 // Verifies that the large cursor accessibility feature can be controlled 2307 // through policy. 2308 chromeos::AccessibilityManager* accessibility_manager = 2309 chromeos::AccessibilityManager::Get(); 2310 2311 // Manually enable the large cursor. 2312 accessibility_manager->EnableLargeCursor(true); 2313 EXPECT_TRUE(accessibility_manager->IsLargeCursorEnabled()); 2314 2315 // Verify that policy overrides the manual setting. 2316 PolicyMap policies; 2317 policies.Set(key::kLargeCursorEnabled, POLICY_LEVEL_MANDATORY, 2318 POLICY_SCOPE_USER, 2319 base::Value::CreateBooleanValue(false), NULL); 2320 UpdateProviderPolicy(policies); 2321 EXPECT_FALSE(accessibility_manager->IsLargeCursorEnabled()); 2322 2323 // Verify that the large cursor cannot be enabled manually anymore. 2324 accessibility_manager->EnableLargeCursor(true); 2325 EXPECT_FALSE(accessibility_manager->IsLargeCursorEnabled()); 2326 } 2327 2328 IN_PROC_BROWSER_TEST_F(PolicyTest, SpokenFeedbackEnabled) { 2329 // Verifies that the spoken feedback accessibility feature can be controlled 2330 // through policy. 2331 chromeos::AccessibilityManager* accessibility_manager = 2332 chromeos::AccessibilityManager::Get(); 2333 2334 // Manually enable spoken feedback. 2335 accessibility_manager->EnableSpokenFeedback( 2336 true, ash::A11Y_NOTIFICATION_NONE); 2337 EXPECT_TRUE(accessibility_manager->IsSpokenFeedbackEnabled()); 2338 2339 // Verify that policy overrides the manual setting. 2340 PolicyMap policies; 2341 policies.Set(key::kSpokenFeedbackEnabled, POLICY_LEVEL_MANDATORY, 2342 POLICY_SCOPE_USER, 2343 base::Value::CreateBooleanValue(false), NULL); 2344 UpdateProviderPolicy(policies); 2345 EXPECT_FALSE(accessibility_manager->IsSpokenFeedbackEnabled()); 2346 2347 // Verify that spoken feedback cannot be enabled manually anymore. 2348 accessibility_manager->EnableSpokenFeedback( 2349 true, ash::A11Y_NOTIFICATION_NONE); 2350 EXPECT_FALSE(accessibility_manager->IsSpokenFeedbackEnabled()); 2351 } 2352 2353 IN_PROC_BROWSER_TEST_F(PolicyTest, HighContrastEnabled) { 2354 // Verifies that the high contrast mode accessibility feature can be 2355 // controlled through policy. 2356 chromeos::AccessibilityManager* accessibility_manager = 2357 chromeos::AccessibilityManager::Get(); 2358 2359 // Manually enable high contrast mode. 2360 accessibility_manager->EnableHighContrast(true); 2361 EXPECT_TRUE(accessibility_manager->IsHighContrastEnabled()); 2362 2363 // Verify that policy overrides the manual setting. 2364 PolicyMap policies; 2365 policies.Set(key::kHighContrastEnabled, POLICY_LEVEL_MANDATORY, 2366 POLICY_SCOPE_USER, 2367 base::Value::CreateBooleanValue(false), NULL); 2368 UpdateProviderPolicy(policies); 2369 EXPECT_FALSE(accessibility_manager->IsHighContrastEnabled()); 2370 2371 // Verify that high contrast mode cannot be enabled manually anymore. 2372 accessibility_manager->EnableHighContrast(true); 2373 EXPECT_FALSE(accessibility_manager->IsHighContrastEnabled()); 2374 } 2375 2376 IN_PROC_BROWSER_TEST_F(PolicyTest, ScreenMagnifierTypeNone) { 2377 // Verifies that the screen magnifier can be disabled through policy. 2378 chromeos::MagnificationManager* magnification_manager = 2379 chromeos::MagnificationManager::Get(); 2380 2381 // Manually enable the full-screen magnifier. 2382 magnification_manager->SetMagnifierType(ash::MAGNIFIER_FULL); 2383 magnification_manager->SetMagnifierEnabled(true); 2384 EXPECT_EQ(ash::MAGNIFIER_FULL, magnification_manager->GetMagnifierType()); 2385 EXPECT_TRUE(magnification_manager->IsMagnifierEnabled()); 2386 2387 // Verify that policy overrides the manual setting. 2388 PolicyMap policies; 2389 policies.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY, 2390 POLICY_SCOPE_USER, 2391 base::Value::CreateIntegerValue(0), NULL); 2392 UpdateProviderPolicy(policies); 2393 EXPECT_FALSE(magnification_manager->IsMagnifierEnabled()); 2394 2395 // Verify that the screen magnifier cannot be enabled manually anymore. 2396 magnification_manager->SetMagnifierEnabled(true); 2397 EXPECT_FALSE(magnification_manager->IsMagnifierEnabled()); 2398 } 2399 2400 IN_PROC_BROWSER_TEST_F(PolicyTest, ScreenMagnifierTypeFull) { 2401 // Verifies that the full-screen magnifier can be enabled through policy. 2402 chromeos::MagnificationManager* magnification_manager = 2403 chromeos::MagnificationManager::Get(); 2404 2405 // Verify that the screen magnifier is initially disabled. 2406 EXPECT_FALSE(magnification_manager->IsMagnifierEnabled()); 2407 2408 // Verify that policy can enable the full-screen magnifier. 2409 PolicyMap policies; 2410 policies.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY, 2411 POLICY_SCOPE_USER, 2412 base::Value::CreateIntegerValue(ash::MAGNIFIER_FULL), NULL); 2413 UpdateProviderPolicy(policies); 2414 EXPECT_EQ(ash::MAGNIFIER_FULL, magnification_manager->GetMagnifierType()); 2415 EXPECT_TRUE(magnification_manager->IsMagnifierEnabled()); 2416 2417 // Verify that the screen magnifier cannot be disabled manually anymore. 2418 magnification_manager->SetMagnifierEnabled(false); 2419 EXPECT_TRUE(magnification_manager->IsMagnifierEnabled()); 2420 } 2421 2422 IN_PROC_BROWSER_TEST_F(PolicyTest, AccessibilityVirtualKeyboardEnabled) { 2423 // Verifies that the on-screen keyboard accessibility feature can be 2424 // controlled through policy. 2425 chromeos::AccessibilityManager* accessibility_manager = 2426 chromeos::AccessibilityManager::Get(); 2427 2428 // Manually enable the on-screen keyboard. 2429 accessibility_manager->EnableVirtualKeyboard(true); 2430 EXPECT_TRUE(accessibility_manager->IsVirtualKeyboardEnabled()); 2431 2432 // Verify that policy overrides the manual setting. 2433 PolicyMap policies; 2434 policies.Set(key::kVirtualKeyboardEnabled, POLICY_LEVEL_MANDATORY, 2435 POLICY_SCOPE_USER, 2436 base::Value::CreateBooleanValue(false), NULL); 2437 UpdateProviderPolicy(policies); 2438 EXPECT_FALSE(accessibility_manager->IsVirtualKeyboardEnabled()); 2439 2440 // Verify that the on-screen keyboard cannot be enabled manually anymore. 2441 accessibility_manager->EnableVirtualKeyboard(true); 2442 EXPECT_FALSE(accessibility_manager->IsVirtualKeyboardEnabled()); 2443 } 2444 2445 IN_PROC_BROWSER_TEST_F(PolicyTest, VirtualKeyboardEnabled) { 2446 // Verify keyboard disabled by default. 2447 EXPECT_FALSE(keyboard::IsKeyboardEnabled()); 2448 // Verify keyboard can be toggled by default. 2449 keyboard::SetTouchKeyboardEnabled(true); 2450 EXPECT_TRUE(keyboard::IsKeyboardEnabled()); 2451 keyboard::SetTouchKeyboardEnabled(false); 2452 EXPECT_FALSE(keyboard::IsKeyboardEnabled()); 2453 2454 // Verify enabling the policy takes effect immediately and that that user 2455 // cannot disable the keyboard.. 2456 PolicyMap policies; 2457 policies.Set(key::kTouchVirtualKeyboardEnabled, 2458 POLICY_LEVEL_MANDATORY, 2459 POLICY_SCOPE_USER, 2460 base::Value::CreateBooleanValue(true), 2461 NULL); 2462 UpdateProviderPolicy(policies); 2463 EXPECT_TRUE(keyboard::IsKeyboardEnabled()); 2464 keyboard::SetTouchKeyboardEnabled(false); 2465 EXPECT_TRUE(keyboard::IsKeyboardEnabled()); 2466 2467 // Verify that disabling the policy takes effect immediately and that the user 2468 // cannot enable the keyboard. 2469 policies.Set(key::kTouchVirtualKeyboardEnabled, 2470 POLICY_LEVEL_MANDATORY, 2471 POLICY_SCOPE_USER, 2472 base::Value::CreateBooleanValue(false), 2473 NULL); 2474 UpdateProviderPolicy(policies); 2475 EXPECT_FALSE(keyboard::IsKeyboardEnabled()); 2476 keyboard::SetTouchKeyboardEnabled(true); 2477 EXPECT_FALSE(keyboard::IsKeyboardEnabled()); 2478 } 2479 2480 #endif 2481 2482 namespace { 2483 2484 static const char* kRestoredURLs[] = { 2485 "http://aaa.com/empty.html", 2486 "http://bbb.com/empty.html", 2487 }; 2488 2489 bool IsNonSwitchArgument(const CommandLine::StringType& s) { 2490 return s.empty() || s[0] != '-'; 2491 } 2492 2493 } // namespace 2494 2495 // Similar to PolicyTest but allows setting policies before the browser is 2496 // created. Each test parameter is a method that sets up the early policies 2497 // and stores the expected startup URLs in |expected_urls_|. 2498 class RestoreOnStartupPolicyTest 2499 : public PolicyTest, 2500 public testing::WithParamInterface< 2501 void (RestoreOnStartupPolicyTest::*)(void)> { 2502 public: 2503 RestoreOnStartupPolicyTest() {} 2504 virtual ~RestoreOnStartupPolicyTest() {} 2505 2506 #if defined(OS_CHROMEOS) 2507 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 2508 // TODO(nkostylev): Investigate if we can remove this switch. 2509 command_line->AppendSwitch(switches::kCreateBrowserOnStartupForTests); 2510 PolicyTest::SetUpCommandLine(command_line); 2511 } 2512 #endif 2513 2514 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE { 2515 PolicyTest::SetUpInProcessBrowserTestFixture(); 2516 // Set early policies now, before the browser is created. 2517 (this->*(GetParam()))(); 2518 2519 // Remove the non-switch arguments, so that session restore kicks in for 2520 // these tests. 2521 CommandLine* command_line = CommandLine::ForCurrentProcess(); 2522 CommandLine::StringVector argv = command_line->argv(); 2523 argv.erase(std::remove_if(++argv.begin(), argv.end(), IsNonSwitchArgument), 2524 argv.end()); 2525 command_line->InitFromArgv(argv); 2526 ASSERT_TRUE(std::equal(argv.begin(), argv.end(), 2527 command_line->argv().begin())); 2528 2529 // Redirect the test URLs to the test data directory. 2530 RedirectHostsToTestData(kRestoredURLs, arraysize(kRestoredURLs)); 2531 } 2532 2533 void HomepageIsNotNTP() { 2534 // Verifies that policy can set the startup pages to the homepage, when 2535 // the homepage is not the NTP. 2536 PolicyMap policies; 2537 policies.Set( 2538 key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2539 base::Value::CreateIntegerValue( 2540 SessionStartupPref::kPrefValueHomePage), 2541 NULL); 2542 policies.Set( 2543 key::kHomepageIsNewTabPage, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2544 base::Value::CreateBooleanValue(false), NULL); 2545 policies.Set( 2546 key::kHomepageLocation, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2547 base::Value::CreateStringValue(kRestoredURLs[1]), NULL); 2548 provider_.UpdateChromePolicy(policies); 2549 2550 expected_urls_.push_back(GURL(kRestoredURLs[1])); 2551 } 2552 2553 void HomepageIsNTP() { 2554 // Verifies that policy can set the startup pages to the homepage, when 2555 // the homepage is the NTP. 2556 PolicyMap policies; 2557 policies.Set( 2558 key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2559 base::Value::CreateIntegerValue( 2560 SessionStartupPref::kPrefValueHomePage), 2561 NULL); 2562 policies.Set( 2563 key::kHomepageIsNewTabPage, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2564 base::Value::CreateBooleanValue(true), NULL); 2565 provider_.UpdateChromePolicy(policies); 2566 2567 expected_urls_.push_back(GURL(chrome::kChromeUINewTabURL)); 2568 } 2569 2570 void ListOfURLs() { 2571 // Verifies that policy can set the startup pages to a list of URLs. 2572 base::ListValue urls; 2573 for (size_t i = 0; i < arraysize(kRestoredURLs); ++i) { 2574 urls.Append(base::Value::CreateStringValue(kRestoredURLs[i])); 2575 expected_urls_.push_back(GURL(kRestoredURLs[i])); 2576 } 2577 PolicyMap policies; 2578 policies.Set( 2579 key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2580 base::Value::CreateIntegerValue(SessionStartupPref::kPrefValueURLs), 2581 NULL); 2582 policies.Set( 2583 key::kRestoreOnStartupURLs, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2584 urls.DeepCopy(), NULL); 2585 provider_.UpdateChromePolicy(policies); 2586 } 2587 2588 void NTP() { 2589 // Verifies that policy can set the startup page to the NTP. 2590 PolicyMap policies; 2591 policies.Set( 2592 key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2593 base::Value::CreateIntegerValue(SessionStartupPref::kPrefValueNewTab), 2594 NULL); 2595 provider_.UpdateChromePolicy(policies); 2596 expected_urls_.push_back(GURL(chrome::kChromeUINewTabURL)); 2597 } 2598 2599 void Last() { 2600 // Verifies that policy can set the startup pages to the last session. 2601 PolicyMap policies; 2602 policies.Set( 2603 key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2604 base::Value::CreateIntegerValue(SessionStartupPref::kPrefValueLast), 2605 NULL); 2606 provider_.UpdateChromePolicy(policies); 2607 // This should restore the tabs opened at PRE_RunTest below. 2608 for (size_t i = 0; i < arraysize(kRestoredURLs); ++i) 2609 expected_urls_.push_back(GURL(kRestoredURLs[i])); 2610 } 2611 2612 std::vector<GURL> expected_urls_; 2613 }; 2614 2615 IN_PROC_BROWSER_TEST_P(RestoreOnStartupPolicyTest, PRE_RunTest) { 2616 // Open some tabs to verify if they are restored after the browser restarts. 2617 // Most policy settings override this, except kPrefValueLast which enforces 2618 // a restore. 2619 ui_test_utils::NavigateToURL(browser(), GURL(kRestoredURLs[0])); 2620 for (size_t i = 1; i < arraysize(kRestoredURLs); ++i) { 2621 content::WindowedNotificationObserver observer( 2622 content::NOTIFICATION_LOAD_STOP, 2623 content::NotificationService::AllSources()); 2624 chrome::AddSelectedTabWithURL(browser(), GURL(kRestoredURLs[i]), 2625 content::PAGE_TRANSITION_LINK); 2626 observer.Wait(); 2627 } 2628 } 2629 2630 IN_PROC_BROWSER_TEST_P(RestoreOnStartupPolicyTest, RunTest) { 2631 #if defined(OS_WIN) && defined(USE_ASH) 2632 // Disable this test in Metro+Ash for now (http://crbug.com/262796). 2633 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests)) 2634 return; 2635 #endif 2636 2637 TabStripModel* model = browser()->tab_strip_model(); 2638 int size = static_cast<int>(expected_urls_.size()); 2639 EXPECT_EQ(size, model->count()); 2640 for (int i = 0; i < size && i < model->count(); ++i) { 2641 EXPECT_EQ(expected_urls_[i], model->GetWebContentsAt(i)->GetURL()); 2642 } 2643 } 2644 2645 INSTANTIATE_TEST_CASE_P( 2646 RestoreOnStartupPolicyTestInstance, 2647 RestoreOnStartupPolicyTest, 2648 testing::Values(&RestoreOnStartupPolicyTest::HomepageIsNotNTP, 2649 &RestoreOnStartupPolicyTest::HomepageIsNTP, 2650 &RestoreOnStartupPolicyTest::ListOfURLs, 2651 &RestoreOnStartupPolicyTest::NTP, 2652 &RestoreOnStartupPolicyTest::Last)); 2653 2654 // Similar to PolicyTest but sets a couple of policies before the browser is 2655 // started. 2656 class PolicyStatisticsCollectorTest : public PolicyTest { 2657 public: 2658 PolicyStatisticsCollectorTest() {} 2659 virtual ~PolicyStatisticsCollectorTest() {} 2660 2661 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE { 2662 PolicyTest::SetUpInProcessBrowserTestFixture(); 2663 PolicyMap policies; 2664 policies.Set( 2665 key::kShowHomeButton, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2666 base::Value::CreateBooleanValue(true), NULL); 2667 policies.Set( 2668 key::kBookmarkBarEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2669 base::Value::CreateBooleanValue(false), NULL); 2670 policies.Set( 2671 key::kHomepageLocation, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2672 base::Value::CreateStringValue("http://chromium.org"), NULL); 2673 provider_.UpdateChromePolicy(policies); 2674 } 2675 }; 2676 2677 IN_PROC_BROWSER_TEST_F(PolicyStatisticsCollectorTest, Startup) { 2678 // Verifies that policy usage histograms are collected at startup. 2679 2680 // BrowserPolicyConnector::Init() has already been called. Make sure the 2681 // CompleteInitialization() task has executed as well. 2682 content::RunAllPendingInMessageLoop(); 2683 2684 GURL kAboutHistograms = GURL(std::string(url::kAboutScheme) + 2685 std::string(url::kStandardSchemeSeparator) + 2686 std::string(content::kChromeUIHistogramHost)); 2687 ui_test_utils::NavigateToURL(browser(), kAboutHistograms); 2688 content::WebContents* contents = 2689 browser()->tab_strip_model()->GetActiveWebContents(); 2690 std::string text; 2691 ASSERT_TRUE(content::ExecuteScriptAndExtractString( 2692 contents, 2693 "var nodes = document.querySelectorAll('body > pre');" 2694 "var result = '';" 2695 "for (var i = 0; i < nodes.length; ++i) {" 2696 " var text = nodes[i].innerHTML;" 2697 " if (text.indexOf('Histogram: Enterprise.Policies') === 0) {" 2698 " result = text;" 2699 " break;" 2700 " }" 2701 "}" 2702 "domAutomationController.send(result);", 2703 &text)); 2704 ASSERT_FALSE(text.empty()); 2705 const std::string kExpectedLabel = 2706 "Histogram: Enterprise.Policies recorded 3 samples"; 2707 EXPECT_EQ(kExpectedLabel, text.substr(0, kExpectedLabel.size())); 2708 // HomepageLocation has policy ID 1. 2709 EXPECT_NE(std::string::npos, text.find("<br>1 ---")); 2710 // ShowHomeButton has policy ID 35. 2711 EXPECT_NE(std::string::npos, text.find("<br>35 ---")); 2712 // BookmarkBarEnabled has policy ID 82. 2713 EXPECT_NE(std::string::npos, text.find("<br>82 ---")); 2714 } 2715 2716 class MediaStreamDevicesControllerBrowserTest 2717 : public PolicyTest, 2718 public testing::WithParamInterface<bool> { 2719 public: 2720 MediaStreamDevicesControllerBrowserTest() 2721 : request_url_allowed_via_whitelist_(false) { 2722 policy_value_ = GetParam(); 2723 } 2724 virtual ~MediaStreamDevicesControllerBrowserTest() {} 2725 2726 // Configure a given policy map. 2727 // The |policy_name| is the name of either the audio or video capture allow 2728 // policy and must never be NULL. 2729 // |whitelist_policy| and |allow_rule| are optional. If NULL, no whitelist 2730 // policy is set. If non-NULL, the request_url_ will be set to be non empty 2731 // and the whitelist policy is set to contain either the |allow_rule| (if 2732 // non-NULL) or an "allow all" wildcard. 2733 void ConfigurePolicyMap(PolicyMap* policies, const char* policy_name, 2734 const char* whitelist_policy, 2735 const char* allow_rule) { 2736 policies->Set(policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 2737 base::Value::CreateBooleanValue(policy_value_), NULL); 2738 2739 if (whitelist_policy) { 2740 // TODO(tommi): Remove the kiosk mode flag when the whitelist is visible 2741 // in the media exceptions UI. 2742 // See discussion here: https://codereview.chromium.org/15738004/ 2743 CommandLine::ForCurrentProcess()->AppendSwitch(switches::kKioskMode); 2744 2745 // Add an entry to the whitelist that allows the specified URL regardless 2746 // of the setting of kAudioCapturedAllowed. 2747 request_url_ = GURL("http://www.example.com/foo"); 2748 base::ListValue* list = new base::ListValue(); 2749 if (allow_rule) { 2750 list->AppendString(allow_rule); 2751 request_url_allowed_via_whitelist_ = true; 2752 } else { 2753 list->AppendString(ContentSettingsPattern::Wildcard().ToString()); 2754 // We should ignore all wildcard entries in the whitelist, so even 2755 // though we've added an entry, it should be ignored and our expectation 2756 // is that the request has not been allowed via the whitelist. 2757 request_url_allowed_via_whitelist_ = false; 2758 } 2759 policies->Set(whitelist_policy, POLICY_LEVEL_MANDATORY, 2760 POLICY_SCOPE_USER, list, NULL); 2761 } 2762 } 2763 2764 void Accept(const content::MediaStreamDevices& devices, 2765 content::MediaStreamRequestResult result, 2766 scoped_ptr<content::MediaStreamUI> ui) { 2767 if (policy_value_ || request_url_allowed_via_whitelist_) { 2768 ASSERT_EQ(1U, devices.size()); 2769 ASSERT_EQ("fake_dev", devices[0].id); 2770 } else { 2771 ASSERT_EQ(0U, devices.size()); 2772 } 2773 } 2774 2775 void FinishAudioTest() { 2776 content::MediaStreamRequest request(0, 0, 0, 2777 request_url_.GetOrigin(), false, 2778 content::MEDIA_DEVICE_ACCESS, 2779 std::string(), std::string(), 2780 content::MEDIA_DEVICE_AUDIO_CAPTURE, 2781 content::MEDIA_NO_SERVICE); 2782 // TODO(raymes): Test MEDIA_DEVICE_OPEN (Pepper) which grants both webcam 2783 // and microphone permissions at the same time. 2784 MediaStreamDevicesController controller( 2785 browser()->tab_strip_model()->GetActiveWebContents(), request, 2786 base::Bind(&MediaStreamDevicesControllerBrowserTest::Accept, this)); 2787 controller.Accept(false); 2788 2789 base::MessageLoop::current()->QuitWhenIdle(); 2790 } 2791 2792 void FinishVideoTest() { 2793 // TODO(raymes): Test MEDIA_DEVICE_OPEN (Pepper) which grants both webcam 2794 // and microphone permissions at the same time. 2795 content::MediaStreamRequest request(0, 0, 0, 2796 request_url_.GetOrigin(), false, 2797 content::MEDIA_DEVICE_ACCESS, 2798 std::string(), 2799 std::string(), 2800 content::MEDIA_NO_SERVICE, 2801 content::MEDIA_DEVICE_VIDEO_CAPTURE); 2802 MediaStreamDevicesController controller( 2803 browser()->tab_strip_model()->GetActiveWebContents(), request, 2804 base::Bind(&MediaStreamDevicesControllerBrowserTest::Accept, this)); 2805 controller.Accept(false); 2806 2807 base::MessageLoop::current()->QuitWhenIdle(); 2808 } 2809 2810 bool policy_value_; 2811 bool request_url_allowed_via_whitelist_; 2812 GURL request_url_; 2813 static const char kExampleRequestPattern[]; 2814 }; 2815 2816 // static 2817 const char MediaStreamDevicesControllerBrowserTest::kExampleRequestPattern[] = 2818 "http://[*.]example.com/"; 2819 2820 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest, 2821 AudioCaptureAllowed) { 2822 content::MediaStreamDevices audio_devices; 2823 content::MediaStreamDevice fake_audio_device( 2824 content::MEDIA_DEVICE_AUDIO_CAPTURE, "fake_dev", "Fake Audio Device"); 2825 audio_devices.push_back(fake_audio_device); 2826 2827 PolicyMap policies; 2828 ConfigurePolicyMap(&policies, key::kAudioCaptureAllowed, NULL, NULL); 2829 UpdateProviderPolicy(policies); 2830 2831 content::BrowserThread::PostTaskAndReply( 2832 content::BrowserThread::IO, FROM_HERE, 2833 base::Bind(&MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices, 2834 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()), 2835 audio_devices), 2836 base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishAudioTest, 2837 this)); 2838 2839 base::MessageLoop::current()->Run(); 2840 } 2841 2842 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest, 2843 AudioCaptureAllowedUrls) { 2844 content::MediaStreamDevices audio_devices; 2845 content::MediaStreamDevice fake_audio_device( 2846 content::MEDIA_DEVICE_AUDIO_CAPTURE, "fake_dev", "Fake Audio Device"); 2847 audio_devices.push_back(fake_audio_device); 2848 2849 const char* allow_pattern[] = { 2850 kExampleRequestPattern, 2851 // This will set an allow-all policy whitelist. Since we do not allow 2852 // setting an allow-all entry in the whitelist, this entry should be ignored 2853 // and therefore the request should be denied. 2854 NULL, 2855 }; 2856 2857 for (size_t i = 0; i < arraysize(allow_pattern); ++i) { 2858 PolicyMap policies; 2859 ConfigurePolicyMap(&policies, key::kAudioCaptureAllowed, 2860 key::kAudioCaptureAllowedUrls, allow_pattern[i]); 2861 UpdateProviderPolicy(policies); 2862 2863 content::BrowserThread::PostTaskAndReply( 2864 content::BrowserThread::IO, FROM_HERE, 2865 base::Bind( 2866 &MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices, 2867 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()), 2868 audio_devices), 2869 base::Bind( 2870 &MediaStreamDevicesControllerBrowserTest::FinishAudioTest, 2871 this)); 2872 2873 base::MessageLoop::current()->Run(); 2874 } 2875 } 2876 2877 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest, 2878 VideoCaptureAllowed) { 2879 content::MediaStreamDevices video_devices; 2880 content::MediaStreamDevice fake_video_device( 2881 content::MEDIA_DEVICE_VIDEO_CAPTURE, "fake_dev", "Fake Video Device"); 2882 video_devices.push_back(fake_video_device); 2883 2884 PolicyMap policies; 2885 ConfigurePolicyMap(&policies, key::kVideoCaptureAllowed, NULL, NULL); 2886 UpdateProviderPolicy(policies); 2887 2888 content::BrowserThread::PostTaskAndReply( 2889 content::BrowserThread::IO, FROM_HERE, 2890 base::Bind(&MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices, 2891 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()), 2892 video_devices), 2893 base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishVideoTest, 2894 this)); 2895 2896 base::MessageLoop::current()->Run(); 2897 } 2898 2899 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest, 2900 VideoCaptureAllowedUrls) { 2901 content::MediaStreamDevices video_devices; 2902 content::MediaStreamDevice fake_video_device( 2903 content::MEDIA_DEVICE_VIDEO_CAPTURE, "fake_dev", "Fake Video Device"); 2904 video_devices.push_back(fake_video_device); 2905 2906 const char* allow_pattern[] = { 2907 kExampleRequestPattern, 2908 // This will set an allow-all policy whitelist. Since we do not allow 2909 // setting an allow-all entry in the whitelist, this entry should be ignored 2910 // and therefore the request should be denied. 2911 NULL, 2912 }; 2913 2914 for (size_t i = 0; i < arraysize(allow_pattern); ++i) { 2915 PolicyMap policies; 2916 ConfigurePolicyMap(&policies, key::kVideoCaptureAllowed, 2917 key::kVideoCaptureAllowedUrls, allow_pattern[i]); 2918 UpdateProviderPolicy(policies); 2919 2920 content::BrowserThread::PostTaskAndReply( 2921 content::BrowserThread::IO, FROM_HERE, 2922 base::Bind(&MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices, 2923 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()), 2924 video_devices), 2925 base::Bind( 2926 &MediaStreamDevicesControllerBrowserTest::FinishVideoTest, 2927 this)); 2928 2929 base::MessageLoop::current()->Run(); 2930 } 2931 } 2932 2933 INSTANTIATE_TEST_CASE_P(MediaStreamDevicesControllerBrowserTestInstance, 2934 MediaStreamDevicesControllerBrowserTest, 2935 testing::Bool()); 2936 2937 #if !defined(OS_CHROMEOS) 2938 // Similar to PolicyTest but sets the proper policy before the browser is 2939 // started. 2940 class PolicyVariationsServiceTest : public PolicyTest { 2941 public: 2942 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE { 2943 PolicyTest::SetUpInProcessBrowserTestFixture(); 2944 PolicyMap policies; 2945 policies.Set( 2946 key::kVariationsRestrictParameter, 2947 POLICY_LEVEL_MANDATORY, 2948 POLICY_SCOPE_USER, 2949 base::Value::CreateStringValue("restricted"), 2950 NULL); 2951 provider_.UpdateChromePolicy(policies); 2952 } 2953 }; 2954 2955 IN_PROC_BROWSER_TEST_F(PolicyVariationsServiceTest, VariationsURLIsValid) { 2956 const std::string default_variations_url = 2957 chrome_variations::VariationsService:: 2958 GetDefaultVariationsServerURLForTesting(); 2959 2960 const GURL url = 2961 chrome_variations::VariationsService::GetVariationsServerURL( 2962 g_browser_process->local_state()); 2963 EXPECT_TRUE(StartsWithASCII(url.spec(), default_variations_url, true)); 2964 std::string value; 2965 EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value)); 2966 EXPECT_EQ("restricted", value); 2967 } 2968 2969 IN_PROC_BROWSER_TEST_F(PolicyTest, NativeMessagingBlacklistSelective) { 2970 base::ListValue blacklist; 2971 blacklist.Append(base::Value::CreateStringValue("host.name")); 2972 PolicyMap policies; 2973 policies.Set(key::kNativeMessagingBlacklist, POLICY_LEVEL_MANDATORY, 2974 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 2975 UpdateProviderPolicy(policies); 2976 2977 PrefService* prefs = browser()->profile()->GetPrefs(); 2978 EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed( 2979 prefs, "host.name")); 2980 EXPECT_TRUE(extensions::NativeMessageProcessHost::IsHostAllowed( 2981 prefs, "other.host.name")); 2982 } 2983 2984 IN_PROC_BROWSER_TEST_F(PolicyTest, NativeMessagingBlacklistWildcard) { 2985 base::ListValue blacklist; 2986 blacklist.Append(base::Value::CreateStringValue("*")); 2987 PolicyMap policies; 2988 policies.Set(key::kNativeMessagingBlacklist, POLICY_LEVEL_MANDATORY, 2989 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 2990 UpdateProviderPolicy(policies); 2991 2992 PrefService* prefs = browser()->profile()->GetPrefs(); 2993 EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed( 2994 prefs, "host.name")); 2995 EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed( 2996 prefs, "other.host.name")); 2997 } 2998 2999 IN_PROC_BROWSER_TEST_F(PolicyTest, NativeMessagingWhitelist) { 3000 base::ListValue blacklist; 3001 blacklist.Append(base::Value::CreateStringValue("*")); 3002 base::ListValue whitelist; 3003 whitelist.Append(base::Value::CreateStringValue("host.name")); 3004 PolicyMap policies; 3005 policies.Set(key::kNativeMessagingBlacklist, POLICY_LEVEL_MANDATORY, 3006 POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL); 3007 policies.Set(key::kNativeMessagingWhitelist, POLICY_LEVEL_MANDATORY, 3008 POLICY_SCOPE_USER, whitelist.DeepCopy(), NULL); 3009 UpdateProviderPolicy(policies); 3010 3011 PrefService* prefs = browser()->profile()->GetPrefs(); 3012 EXPECT_TRUE(extensions::NativeMessageProcessHost::IsHostAllowed( 3013 prefs, "host.name")); 3014 EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed( 3015 prefs, "other.host.name")); 3016 } 3017 3018 IN_PROC_BROWSER_TEST_F(PolicyTest, 3019 EnableDeprecatedWebPlatformFeatures_ShowModalDialog) { 3020 base::ListValue enabled_features; 3021 enabled_features.Append(new base::StringValue( 3022 "ShowModalDialog_EffectiveUntil20150430")); 3023 PolicyMap policies; 3024 policies.Set(key::kEnableDeprecatedWebPlatformFeatures, 3025 POLICY_LEVEL_MANDATORY, 3026 POLICY_SCOPE_USER, 3027 enabled_features.DeepCopy(), 3028 NULL); 3029 UpdateProviderPolicy(policies); 3030 3031 // Policy only takes effect on new browsers, not existing browsers, so create 3032 // a new browser. 3033 Browser* browser2 = CreateBrowser(browser()->profile()); 3034 ui_test_utils::NavigateToURL(browser2, GURL(url::kAboutBlankURL)); 3035 bool result = false; 3036 EXPECT_TRUE(content::ExecuteScriptAndExtractBool( 3037 browser2->tab_strip_model()->GetActiveWebContents(), 3038 "domAutomationController.send(window.showModalDialog !== undefined);", 3039 &result)); 3040 EXPECT_TRUE(result); 3041 } 3042 3043 #endif // !defined(CHROME_OS) 3044 3045 } // namespace policy 3046