src/chrome/browser/policy/policy_browsertest.cc

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