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