#include "base/bind_helpers.h"
#include "base/callback.h"
#include "base/command_line.h"
-#include "base/file_util.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
+#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/memory/ref_counted.h"
#include "base/path_service.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/test_file_util.h"
+#include "base/threading/sequenced_worker_pool.h"
#include "base/time/time.h"
#include "base/values.h"
#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/content_settings/tab_specific_content_settings.h"
-#include "chrome/browser/devtools/devtools_window.h"
+#include "chrome/browser/devtools/devtools_window_testing.h"
#include "chrome/browser/download/download_prefs.h"
+#include "chrome/browser/extensions/api/messaging/native_message_process_host.h"
#include "chrome/browser/extensions/crx_installer.h"
-#include "chrome/browser/extensions/extension_host.h"
-#include "chrome/browser/extensions/extension_process_manager.h"
#include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/extension_system.h"
#include "chrome/browser/extensions/unpacked_installer.h"
+#include "chrome/browser/extensions/updater/extension_cache_fake.h"
#include "chrome/browser/extensions/updater/extension_updater.h"
#include "chrome/browser/infobars/infobar_service.h"
#include "chrome/browser/media/media_capture_devices_dispatcher.h"
#include "chrome/browser/media/media_stream_devices_controller.h"
#include "chrome/browser/metrics/variations/variations_service.h"
+#include "chrome/browser/net/prediction_options.h"
+#include "chrome/browser/net/ssl_config_service_manager.h"
#include "chrome/browser/net/url_request_mock_util.h"
#include "chrome/browser/plugins/plugin_prefs.h"
-#include "chrome/browser/policy/browser_policy_connector.h"
#include "chrome/browser/policy/cloud/test_request_interceptor.h"
-#include "chrome/browser/policy/external_data_fetcher.h"
-#include "chrome/browser/policy/mock_configuration_policy_provider.h"
-#include "chrome/browser/policy/policy_map.h"
+#include "chrome/browser/policy/profile_policy_connector.h"
+#include "chrome/browser/policy/profile_policy_connector_factory.h"
#include "chrome/browser/prefs/session_startup_pref.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/search/instant_service.h"
#include "chrome/browser/search/instant_service_factory.h"
#include "chrome/browser/search/search.h"
-#include "chrome/browser/search_engines/template_url.h"
-#include "chrome/browser/search_engines/template_url_service.h"
#include "chrome/browser/search_engines/template_url_service_factory.h"
-#include "chrome/browser/translate/translate_infobar_delegate.h"
-#include "chrome/browser/translate/translate_tab_helper.h"
+#include "chrome/browser/translate/chrome_translate_client.h"
+#include "chrome/browser/translate/cld_data_harness.h"
+#include "chrome/browser/translate/translate_service.h"
#include "chrome/browser/ui/bookmarks/bookmark_bar.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_commands.h"
#include "chrome/browser/ui/browser_tabstrip.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/browser/ui/host_desktop.h"
-#include "chrome/browser/ui/omnibox/location_bar.h"
+#include "chrome/browser/ui/location_bar/location_bar.h"
#include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
#include "chrome/browser/ui/omnibox/omnibox_view.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_switches.h"
-#include "chrome/common/content_settings.h"
-#include "chrome/common/content_settings_pattern.h"
-#include "chrome/common/extensions/extension.h"
#include "chrome/common/extensions/extension_constants.h"
-#include "chrome/common/extensions/extension_set.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/url_constants.h"
+#include "chrome/grit/generated_resources.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/test_switches.h"
#include "chrome/test/base/ui_test_utils.h"
+#include "components/content_settings/core/common/content_settings.h"
+#include "components/content_settings/core/common/content_settings_pattern.h"
+#include "components/infobars/core/infobar.h"
+#include "components/policy/core/browser/browser_policy_connector.h"
+#include "components/policy/core/common/external_data_fetcher.h"
+#include "components/policy/core/common/mock_configuration_policy_provider.h"
+#include "components/policy/core/common/policy_map.h"
+#include "components/policy/core/common/policy_pref_names.h"
+#include "components/policy/core/common/policy_service.h"
+#include "components/policy/core/common/policy_service_impl.h"
+#include "components/search_engines/template_url.h"
+#include "components/search_engines/template_url_service.h"
+#include "components/translate/core/browser/language_state.h"
+#include "components/translate/core/browser/translate_infobar_delegate.h"
#include "content/public/browser/browser_child_process_host_iterator.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/child_process_data.h"
#include "content/public/browser/download_item.h"
#include "content/public/browser/download_manager.h"
+#include "content/public/browser/gpu_data_manager.h"
#include "content/public/browser/notification_details.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "content/public/browser/web_contents.h"
#include "content/public/common/content_constants.h"
#include "content/public/common/content_paths.h"
-#include "content/public/common/page_transition_types.h"
#include "content/public/common/process_type.h"
#include "content/public/common/result_codes.h"
#include "content/public/common/url_constants.h"
#include "content/public/test/mock_notification_observer.h"
#include "content/public/test/test_navigation_observer.h"
#include "content/public/test/test_utils.h"
-#include "content/test/net/url_request_failed_job.h"
-#include "content/test/net/url_request_mock_http_job.h"
-#include "grit/generated_resources.h"
+#include "extensions/browser/extension_host.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/process_manager.h"
+#include "extensions/browser/uninstall_reason.h"
+#include "extensions/common/constants.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_set.h"
#include "net/base/net_errors.h"
#include "net/base/net_util.h"
#include "net/base/url_util.h"
#include "net/http/http_stream_factory.h"
+#include "net/ssl/ssl_config.h"
+#include "net/ssl/ssl_config_service.h"
+#include "net/test/url_request/url_request_failed_job.h"
+#include "net/test/url_request/url_request_mock_http_job.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_filter.h"
#include "policy/policy_constants.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/page_transition_types.h"
#include "ui/base/resource/resource_bundle.h"
#include "url/gurl.h"
#include "ash/accelerators/accelerator_table.h"
#include "ash/magnifier/magnifier_constants.h"
#include "ash/shell.h"
-#include "ash/shell_delegate.h"
#include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
#include "chrome/browser/chromeos/accessibility/magnification_manager.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/ash/screenshot_taker.h"
#include "chromeos/audio/cras_audio_handler.h"
+#include "ui/keyboard/keyboard_util.h"
#endif
#if !defined(OS_MACOSX)
-#include "apps/shell_window.h"
-#include "apps/shell_window_registry.h"
-#include "apps/ui/native_app_window.h"
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "chrome/browser/ui/extensions/application_launch.h"
+#include "extensions/browser/app_window/app_window.h"
+#include "extensions/browser/app_window/app_window_registry.h"
+#include "extensions/browser/app_window/native_app_window.h"
#include "ui/base/window_open_disposition.h"
#endif
using content::BrowserThread;
-using content::URLRequestMockHTTPJob;
-using testing::AnyNumber;
+using net::URLRequestMockHTTPJob;
using testing::Mock;
using testing::Return;
using testing::_;
for (size_t i = 0; i < size; ++i) {
const GURL url(urls[i]);
EXPECT_TRUE(url.is_valid());
- filter->AddUrlProtocolHandler(url,
- URLRequestMockHTTPJob::CreateProtocolHandler(base_path));
+ filter->AddUrlInterceptor(url,
+ URLRequestMockHTTPJob::CreateInterceptor(
+ base_path, BrowserThread::GetBlockingPool()));
}
}
net::URLRequest* request,
net::NetworkDelegate* network_delegate,
const std::string& scheme) {
- return new content::URLRequestFailedJob(
+ return new net::URLRequestFailedJob(
request, network_delegate, net::ERR_CONNECTION_RESET);
}
ui_test_utils::NavigateToURL(browser, url);
content::WebContents* contents =
browser->tab_strip_model()->GetActiveWebContents();
- EXPECT_EQ(url, contents->GetURL());
- string16 title = UTF8ToUTF16(url.spec() + " was blocked");
- EXPECT_NE(title, contents->GetTitle());
+ ASSERT_EQ(url, contents->GetURL());
+ base::string16 spec16 = base::UTF8ToUTF16(url.spec());
+ base::string16 title =
+ l10n_util::GetStringFUTF16(IDS_ERRORPAGES_TITLE_BLOCKED, spec16);
+ ASSERT_NE(title, contents->GetTitle());
}
// Verifies that access to the given url |spec| is blocked.
ui_test_utils::NavigateToURL(browser, url);
content::WebContents* contents =
browser->tab_strip_model()->GetActiveWebContents();
- EXPECT_EQ(url, contents->GetURL());
- string16 title = UTF8ToUTF16(url.spec() + " was blocked");
- EXPECT_EQ(title, contents->GetTitle());
+ ASSERT_EQ(url, contents->GetURL());
+ base::string16 spec16 = base::UTF8ToUTF16(url.spec());
+ base::string16 title =
+ l10n_util::GetStringFUTF16(IDS_ERRORPAGES_TITLE_BLOCKED, spec16);
+ ASSERT_EQ(title, contents->GetTitle());
// Verify that the expected error page is being displayed.
bool result = false;
- EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+ ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
contents,
"var textContent = document.body.textContent;"
"var hasError = textContent.indexOf('ERR_BLOCKED_BY_ADMINISTRATOR') >= 0;"
"domAutomationController.send(hasError);",
&result));
- EXPECT_TRUE(result);
+ ASSERT_TRUE(result);
}
// Downloads a file named |file| and expects it to be saved to |dir|, which
#if defined(OS_CHROMEOS)
int CountScreenshots() {
DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
- ash::Shell::GetInstance()->delegate()->GetCurrentBrowserContext());
+ ProfileManager::GetActiveUserProfile());
base::FileEnumerator enumerator(download_prefs->DownloadPath(),
false, base::FileEnumerator::FILES,
"Screenshot*");
EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
contents,
"var canvas = document.createElement('canvas');"
- "var context = canvas.getContext('experimental-webgl');"
+ "var context = canvas.getContext('webgl');"
"domAutomationController.send(context != null);",
&result));
return result;
bool IsJavascriptEnabled(content::WebContents* contents) {
scoped_ptr<base::Value> value = content::ExecuteScriptAndGetValue(
- contents->GetRenderViewHost(), "123");
+ contents->GetMainFrame(), "123");
int result = 0;
if (!value->GetAsInteger(&result))
EXPECT_EQ(base::Value::TYPE_NULL, value->GetType());
return result == 123;
}
+bool IsNetworkPredictionEnabled(PrefService* prefs) {
+ return chrome_browser_net::CanPrefetchAndPrerenderUI(prefs);
+}
+
void CopyPluginListAndQuit(std::vector<content::WebPluginInfo>* out,
const std::vector<content::WebPluginInfo>& in) {
*out = in;
const std::vector<content::WebPluginInfo>& plugins) {
const content::WebPluginInfo* flash = NULL;
for (size_t i = 0; i < plugins.size(); ++i) {
- if (plugins[i].name == ASCIIToUTF16(content::kFlashPluginName)) {
+ if (plugins[i].name == base::ASCIIToUTF16(content::kFlashPluginName)) {
flash = &plugins[i];
break;
}
void FlushBlacklistPolicy() {
// Updates of the URLBlacklist are done on IO, after building the blacklist
- // on FILE, which is initiated from IO.
+ // on the blocking pool, which is initiated from IO.
content::RunAllPendingInMessageLoop(BrowserThread::IO);
- content::RunAllPendingInMessageLoop(BrowserThread::FILE);
+ BrowserThread::GetBlockingPool()->FlushForTesting();
content::RunAllPendingInMessageLoop(BrowserThread::IO);
}
void Wait();
// Overridden WebContentsObserver methods.
- virtual void WebContentsDestroyed(
- content::WebContents* web_contents) OVERRIDE;
+ virtual void WebContentsDestroyed() OVERRIDE;
virtual void DidStopLoading(
content::RenderViewHost* render_view_host) OVERRIDE;
message_loop_runner_->Run();
}
-void WebContentsLoadedOrDestroyedWatcher::WebContentsDestroyed(
- content::WebContents* web_contents) {
+void WebContentsLoadedOrDestroyedWatcher::WebContentsDestroyed() {
message_loop_runner_->Quit();
}
#if !defined(OS_MACOSX)
-// Observer used to wait for the creation of a new shell window.
-class TestAddShellWindowObserver : public apps::ShellWindowRegistry::Observer {
+// Observer used to wait for the creation of a new app window.
+class TestAddAppWindowObserver
+ : public extensions::AppWindowRegistry::Observer {
public:
- explicit TestAddShellWindowObserver(apps::ShellWindowRegistry* registry);
- virtual ~TestAddShellWindowObserver();
+ explicit TestAddAppWindowObserver(extensions::AppWindowRegistry* registry);
+ virtual ~TestAddAppWindowObserver();
- // apps::ShellWindowRegistry::Observer:
- virtual void OnShellWindowAdded(apps::ShellWindow* shell_window) OVERRIDE;
- virtual void OnShellWindowIconChanged(
- apps::ShellWindow* shell_window) OVERRIDE;
- virtual void OnShellWindowRemoved(apps::ShellWindow* shell_window) OVERRIDE;
+ // extensions::AppWindowRegistry::Observer:
+ virtual void OnAppWindowAdded(extensions::AppWindow* app_window) OVERRIDE;
- apps::ShellWindow* WaitForShellWindow();
+ extensions::AppWindow* WaitForAppWindow();
private:
- apps::ShellWindowRegistry* registry_; // Not owned.
- apps::ShellWindow* window_; // Not owned.
+ extensions::AppWindowRegistry* registry_; // Not owned.
+ extensions::AppWindow* window_; // Not owned.
base::RunLoop run_loop_;
- DISALLOW_COPY_AND_ASSIGN(TestAddShellWindowObserver);
+ DISALLOW_COPY_AND_ASSIGN(TestAddAppWindowObserver);
};
-TestAddShellWindowObserver::TestAddShellWindowObserver(
- apps::ShellWindowRegistry* registry)
- : registry_(registry),
- window_(NULL) {
+TestAddAppWindowObserver::TestAddAppWindowObserver(
+ extensions::AppWindowRegistry* registry)
+ : registry_(registry), window_(NULL) {
registry_->AddObserver(this);
}
-TestAddShellWindowObserver::~TestAddShellWindowObserver() {
+TestAddAppWindowObserver::~TestAddAppWindowObserver() {
registry_->RemoveObserver(this);
}
-void TestAddShellWindowObserver::OnShellWindowAdded(
- apps::ShellWindow* shell_window) {
- window_ = shell_window;
+void TestAddAppWindowObserver::OnAppWindowAdded(
+ extensions::AppWindow* app_window) {
+ window_ = app_window;
run_loop_.Quit();
}
-void TestAddShellWindowObserver::OnShellWindowIconChanged(
- apps::ShellWindow* shell_window) {
-}
-
-void TestAddShellWindowObserver::OnShellWindowRemoved(
- apps::ShellWindow* shell_window) {
-}
-
-apps::ShellWindow* TestAddShellWindowObserver::WaitForShellWindow() {
+extensions::AppWindow* TestAddAppWindowObserver::WaitForAppWindow() {
run_loop_.Run();
return window_;
}
PolicyTest() {}
virtual ~PolicyTest() {}
+ virtual void SetUp() OVERRIDE {
+ test_extension_cache_.reset(new extensions::ExtensionCacheFake());
+ InProcessBrowserTest::SetUp();
+ }
+
virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
CommandLine::ForCurrentProcess()->AppendSwitch("noerrdialogs");
EXPECT_CALL(provider_, IsInitializationComplete(_))
.WillRepeatedly(Return(true));
- EXPECT_CALL(provider_, RegisterPolicyDomain(_)).Times(AnyNumber());
BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
}
base::FilePath root_http;
PathService::Get(content::DIR_TEST_DATA, &root_http);
BrowserThread::PostTaskAndReply(
- BrowserThread::IO, FROM_HERE,
- base::Bind(URLRequestMockHTTPJob::AddUrlHandler, root_http),
+ BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(URLRequestMockHTTPJob::AddUrlHandler,
+ root_http,
+ make_scoped_refptr(BrowserThread::GetBlockingPool())),
base::MessageLoop::current()->QuitWhenIdleClosure());
content::RunMessageLoop();
}
void SetScreenshotPolicy(bool enabled) {
PolicyMap policies;
policies.Set(key::kDisableScreenshots,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(!enabled), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(!enabled),
+ NULL);
UpdateProviderPolicy(policies);
}
#if defined(OS_CHROMEOS)
+ class QuitMessageLoopAfterScreenshot : public ScreenshotTakerObserver {
+ public:
+ virtual void OnScreenshotCompleted(
+ ScreenshotTakerObserver::Result screenshot_result,
+ const base::FilePath& screenshot_path) OVERRIDE {
+ BrowserThread::PostTaskAndReply(BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(base::DoNothing),
+ base::MessageLoop::QuitClosure());
+ }
+
+ virtual ~QuitMessageLoopAfterScreenshot() {}
+ };
+
void TestScreenshotFile(bool enabled) {
+ // AddObserver is an ash-specific method, so just replace the screenshot
+ // taker with one we've created here.
+ scoped_ptr<ScreenshotTaker> screenshot_taker(new ScreenshotTaker);
+ // ScreenshotTaker doesn't own this observer, so the observer's lifetime
+ // is tied to the test instead.
+ screenshot_taker->AddObserver(&observer_);
+ ash::Shell::GetInstance()->accelerator_controller()->SetScreenshotDelegate(
+ screenshot_taker.PassAs<ash::ScreenshotDelegate>());
+
SetScreenshotPolicy(enabled);
ash::Shell::GetInstance()->accelerator_controller()->PerformAction(
ash::TAKE_SCREENSHOT, ui::Accelerator());
- // TAKE_SCREENSHOT handler posts write file task on success, wait for it.
- BrowserThread::PostTaskAndReply(
- BrowserThread::IO,
- FROM_HERE,
- base::Bind(base::DoNothing),
- base::MessageLoop::QuitClosure());
content::RunMessageLoop();
}
#endif
installer->set_creation_flags(extensions::Extension::FROM_WEBSTORE);
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
installer->InstallCrx(extension_path);
observer.Wait();
scoped_refptr<extensions::UnpackedInstaller> installer =
extensions::UnpackedInstaller::Create(extension_service());
content::WindowedNotificationObserver observer(
- expect_success ? chrome::NOTIFICATION_EXTENSION_LOADED
- : chrome::NOTIFICATION_EXTENSION_LOAD_ERROR,
+ expect_success ? extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED
+ : extensions::NOTIFICATION_EXTENSION_LOAD_ERROR,
content::NotificationService::AllSources());
installer->Load(extension_path);
observer.Wait();
- const ExtensionSet* extensions = extension_service()->extensions();
- for (ExtensionSet::const_iterator it = extensions->begin();
+ const extensions::ExtensionSet* extensions =
+ extension_service()->extensions();
+ for (extensions::ExtensionSet::const_iterator it = extensions->begin();
it != extensions->end(); ++it) {
if ((*it)->path() == extension_path)
return it->get();
void UninstallExtension(const std::string& id, bool expect_success) {
content::WindowedNotificationObserver observer(
- expect_success ? chrome::NOTIFICATION_EXTENSION_UNINSTALLED
- : chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
+ expect_success
+ ? extensions::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED
+ : extensions::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
content::NotificationService::AllSources());
- extension_service()->UninstallExtension(id, false, NULL);
+ extension_service()->UninstallExtension(
+ id,
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ base::Bind(&base::DoNothing),
+ NULL);
observer.Wait();
}
void PerformClick(int x, int y) {
content::WebContents* contents =
browser()->tab_strip_model()->GetActiveWebContents();
- WebKit::WebMouseEvent click_event;
- click_event.type = WebKit::WebInputEvent::MouseDown;
- click_event.button = WebKit::WebMouseEvent::ButtonLeft;
+ blink::WebMouseEvent click_event;
+ click_event.type = blink::WebInputEvent::MouseDown;
+ click_event.button = blink::WebMouseEvent::ButtonLeft;
click_event.clickCount = 1;
click_event.x = x;
click_event.y = y;
contents->GetRenderViewHost()->ForwardMouseEvent(click_event);
- click_event.type = WebKit::WebInputEvent::MouseUp;
+ click_event.type = blink::WebInputEvent::MouseUp;
contents->GetRenderViewHost()->ForwardMouseEvent(click_event);
}
MockConfigurationPolicyProvider provider_;
+ scoped_ptr<extensions::ExtensionCacheFake> test_extension_cache_;
+#if defined(OS_CHROMEOS)
+ QuitMessageLoopAfterScreenshot observer_;
+#endif
};
#if defined(OS_WIN)
virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
PolicyTest::SetUpInProcessBrowserTestFixture();
PolicyMap policies;
- policies.Set(
- key::kApplicationLocaleValue, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue("fr"), NULL);
+ policies.Set(key::kApplicationLocaleValue,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue("fr"),
+ NULL);
provider_.UpdateChromePolicy(policies);
// The "en-US" ResourceBundle is always loaded before this step for tests,
// but in this test we want the browser to load the bundle as it
// Verifies that the default locale can be overridden with policy.
EXPECT_EQ("fr", g_browser_process->GetApplicationLocale());
ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL));
- string16 french_title = l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE);
- string16 title;
+ base::string16 french_title = l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE);
+ base::string16 title;
EXPECT_TRUE(ui_test_utils::GetCurrentTabTitle(browser(), &title));
EXPECT_EQ(french_title, title);
std::string loaded =
ui::ResourceBundle::GetSharedInstance().ReloadLocaleResources("en-US");
EXPECT_EQ("en-US", loaded);
- string16 english_title = l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE);
+ base::string16 english_title = l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE);
EXPECT_NE(french_title, english_title);
}
#endif
// Test starts in about:blank.
PrefService* prefs = browser()->profile()->GetPrefs();
- EXPECT_FALSE(prefs->IsManagedPreference(prefs::kShowBookmarkBar));
- EXPECT_FALSE(prefs->GetBoolean(prefs::kShowBookmarkBar));
+ EXPECT_FALSE(prefs->IsManagedPreference(bookmarks::prefs::kShowBookmarkBar));
+ EXPECT_FALSE(prefs->GetBoolean(bookmarks::prefs::kShowBookmarkBar));
EXPECT_EQ(BookmarkBar::HIDDEN, browser()->bookmark_bar_state());
PolicyMap policies;
- policies.Set(key::kBookmarkBarEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kBookmarkBarEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
- EXPECT_TRUE(prefs->IsManagedPreference(prefs::kShowBookmarkBar));
- EXPECT_TRUE(prefs->GetBoolean(prefs::kShowBookmarkBar));
+ EXPECT_TRUE(prefs->IsManagedPreference(bookmarks::prefs::kShowBookmarkBar));
+ EXPECT_TRUE(prefs->GetBoolean(bookmarks::prefs::kShowBookmarkBar));
EXPECT_EQ(BookmarkBar::SHOW, browser()->bookmark_bar_state());
// The NTP has special handling of the bookmark bar.
ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL));
EXPECT_EQ(BookmarkBar::SHOW, browser()->bookmark_bar_state());
- policies.Set(key::kBookmarkBarEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kBookmarkBarEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
- EXPECT_TRUE(prefs->IsManagedPreference(prefs::kShowBookmarkBar));
- EXPECT_FALSE(prefs->GetBoolean(prefs::kShowBookmarkBar));
+ EXPECT_TRUE(prefs->IsManagedPreference(bookmarks::prefs::kShowBookmarkBar));
+ EXPECT_FALSE(prefs->GetBoolean(bookmarks::prefs::kShowBookmarkBar));
// The bookmark bar is hidden in the NTP when disabled by policy.
EXPECT_EQ(BookmarkBar::HIDDEN, browser()->bookmark_bar_state());
policies.Clear();
UpdateProviderPolicy(policies);
- EXPECT_FALSE(prefs->IsManagedPreference(prefs::kShowBookmarkBar));
- EXPECT_FALSE(prefs->GetBoolean(prefs::kShowBookmarkBar));
+ EXPECT_FALSE(prefs->IsManagedPreference(bookmarks::prefs::kShowBookmarkBar));
+ EXPECT_FALSE(prefs->GetBoolean(bookmarks::prefs::kShowBookmarkBar));
// The bookmark bar is shown detached in the NTP, when disabled by prefs only.
EXPECT_EQ(BookmarkBar::DETACHED, browser()->bookmark_bar_state());
}
EXPECT_EQ(kCookieValue, GetCookies(browser()->profile(), GURL(kURL)));
// Now set the policy and the cookie should be gone after another restart.
PolicyMap policies;
- policies.Set(key::kDefaultCookiesSetting, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateIntegerValue(4), NULL);
+ policies.Set(key::kDefaultCookiesSetting,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(4),
+ NULL);
UpdateProviderPolicy(policies);
}
// Verifies that a default search is made using the provider configured via
// policy. Also checks that default search can be completely disabled.
- const string16 kKeyword(ASCIIToUTF16("testsearch"));
+ const base::string16 kKeyword(base::ASCIIToUTF16("testsearch"));
const std::string kSearchURL("http://search.example/search?q={searchTerms}");
const std::string kAlternateURL0(
"http://search.example/search#q={searchTerms}");
// Override the default search provider using policies.
PolicyMap policies;
- policies.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kDefaultSearchProviderEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
policies.Set(key::kDefaultSearchProviderKeyword,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kKeyword), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kKeyword),
+ NULL);
policies.Set(key::kDefaultSearchProviderSearchURL,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kSearchURL), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kSearchURL),
+ NULL);
base::ListValue* alternate_urls = new base::ListValue();
alternate_urls->AppendString(kAlternateURL0);
alternate_urls->AppendString(kAlternateURL1);
policies.Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, alternate_urls, NULL);
policies.Set(key::kDefaultSearchProviderSearchTermsReplacementKey,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kSearchTermsReplacementKey),
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kSearchTermsReplacementKey),
NULL);
policies.Set(key::kDefaultSearchProviderImageURL,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kImageURL),
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kImageURL),
NULL);
policies.Set(key::kDefaultSearchProviderImageURLPostParams,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kImageURLPostParams),
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kImageURLPostParams),
NULL);
policies.Set(key::kDefaultSearchProviderNewTabURL,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kNewTabURL),
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kNewTabURL),
NULL);
UpdateProviderPolicy(policies);
default_search = service->GetDefaultSearchProvider();
chrome::FocusLocationBar(browser());
LocationBar* location_bar = browser()->window()->GetLocationBar();
ui_test_utils::SendToOmniboxAndSubmit(location_bar, "stuff to search for");
- OmniboxEditModel* model = location_bar->GetLocationEntry()->model();
+ OmniboxEditModel* model = location_bar->GetOmniboxView()->model();
EXPECT_TRUE(model->CurrentMatch(NULL).destination_url.is_valid());
content::WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
EXPECT_EQ(expected, web_contents->GetURL());
// Verify that searching from the omnibox can be disabled.
- ui_test_utils::NavigateToURL(browser(), GURL(content::kAboutBlankURL));
- policies.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
+ policies.Set(key::kDefaultSearchProviderEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
EXPECT_TRUE(service->GetDefaultSearchProvider());
UpdateProviderPolicy(policies);
EXPECT_FALSE(service->GetDefaultSearchProvider());
ui_test_utils::SendToOmniboxAndSubmit(location_bar, "should not work");
// This means that submitting won't trigger any action.
EXPECT_FALSE(model->CurrentMatch(NULL).destination_url.is_valid());
- EXPECT_EQ(GURL(content::kAboutBlankURL), web_contents->GetURL());
+ EXPECT_EQ(GURL(url::kAboutBlankURL), web_contents->GetURL());
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, PolicyPreprocessing) {
+ // Add an individual proxy policy value.
+ PolicyMap policies;
+ policies.Set(key::kProxyServerMode,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(3),
+ NULL);
+ UpdateProviderPolicy(policies);
+
+ // It should be removed and replaced with a dictionary.
+ PolicyMap expected;
+ scoped_ptr<base::DictionaryValue> expected_value(new base::DictionaryValue);
+ expected_value->SetInteger(key::kProxyServerMode, 3);
+ expected.Set(key::kProxySettings,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ expected_value.release(),
+ NULL);
+
+ // Check both the browser and the profile.
+ const PolicyMap& actual_from_browser =
+ g_browser_process->browser_policy_connector()
+ ->GetPolicyService()
+ ->GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
+ EXPECT_TRUE(expected.Equals(actual_from_browser));
+ const PolicyMap& actual_from_profile =
+ ProfilePolicyConnectorFactory::GetForProfile(browser()->profile())
+ ->policy_service()
+ ->GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
+ EXPECT_TRUE(expected.Equals(actual_from_profile));
}
IN_PROC_BROWSER_TEST_F(PolicyTest, ForceSafeSearch) {
chrome::FocusLocationBar(browser());
LocationBar* location_bar = browser()->window()->GetLocationBar();
ui_test_utils::SendToOmniboxAndSubmit(location_bar, "http://google.com/");
- OmniboxEditModel* model = location_bar->GetLocationEntry()->model();
+ OmniboxEditModel* model = location_bar->GetOmniboxView()->model();
no_safesearch_observer.Wait();
EXPECT_TRUE(model->CurrentMatch(NULL).destination_url.is_valid());
content::WebContents* web_contents =
// Override the default SafeSearch setting using policies.
PolicyMap policies;
- policies.Set(key::kForceSafeSearch, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kForceSafeSearch,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_TRUE(prefs->IsManagedPreference(prefs::kForceSafeSearch));
// Verify that searching from google.com works.
chrome::FocusLocationBar(browser());
- location_bar = browser()->window()->GetLocationBar();
ui_test_utils::SendToOmniboxAndSubmit(location_bar, "http://google.com/");
safesearch_observer.Wait();
- model = location_bar->GetLocationEntry()->model();
EXPECT_TRUE(model->CurrentMatch(NULL).destination_url.is_valid());
web_contents = browser()->tab_strip_model()->GetActiveWebContents();
std::string expected_url("http://google.com/?");
IN_PROC_BROWSER_TEST_F(PolicyTest, ReplaceSearchTerms) {
MakeRequestFail make_request_fail("search.example");
- chrome::EnableInstantExtendedAPIForTesting();
+ chrome::EnableQueryExtractionForTesting();
// Verifies that a default search is made using the provider configured via
// policy. Also checks that default search can be completely disabled.
- const string16 kKeyword(ASCIIToUTF16("testsearch"));
+ const base::string16 kKeyword(base::ASCIIToUTF16("testsearch"));
const std::string kSearchURL("https://www.google.com/search?q={searchTerms}");
const std::string kInstantURL("http://does/not/exist");
const std::string kAlternateURL0(
// Override the default search provider using policies.
PolicyMap policies;
- policies.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kDefaultSearchProviderEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
policies.Set(key::kDefaultSearchProviderKeyword,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kKeyword), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kKeyword),
+ NULL);
policies.Set(key::kDefaultSearchProviderSearchURL,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kSearchURL), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kSearchURL),
+ NULL);
policies.Set(key::kDefaultSearchProviderInstantURL,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kInstantURL), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kInstantURL),
+ NULL);
base::ListValue* alternate_urls = new base::ListValue();
alternate_urls->AppendString(kAlternateURL0);
alternate_urls->AppendString(kAlternateURL1);
policies.Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, alternate_urls, NULL);
policies.Set(key::kDefaultSearchProviderSearchTermsReplacementKey,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kSearchTermsReplacementKey),
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kSearchTermsReplacementKey),
NULL);
UpdateProviderPolicy(policies);
default_search = service->GetDefaultSearchProvider();
// first URL pattern.
chrome::FocusLocationBar(browser());
LocationBar* location_bar = browser()->window()->GetLocationBar();
+ OmniboxView* omnibox_view = location_bar->GetOmniboxView();
ui_test_utils::SendToOmniboxAndSubmit(location_bar,
"https://www.google.com/?espv=1#q=foobar");
EXPECT_TRUE(
browser()->toolbar_model()->WouldPerformSearchTermReplacement(false));
- EXPECT_EQ(ASCIIToUTF16("foobar"),
- location_bar->GetLocationEntry()->GetText());
+ EXPECT_EQ(base::ASCIIToUTF16("foobar"), omnibox_view->GetText());
// Verify that not using espv=1 does not do search term replacement.
chrome::FocusLocationBar(browser());
- location_bar = browser()->window()->GetLocationBar();
ui_test_utils::SendToOmniboxAndSubmit(location_bar,
"https://www.google.com/?q=foobar");
EXPECT_FALSE(
browser()->toolbar_model()->WouldPerformSearchTermReplacement(false));
- EXPECT_EQ(ASCIIToUTF16("https://www.google.com/?q=foobar"),
- location_bar->GetLocationEntry()->GetText());
+ EXPECT_EQ(base::ASCIIToUTF16("https://www.google.com/?q=foobar"),
+ omnibox_view->GetText());
// Verify that searching from the omnibox does search term replacement with
// second URL pattern.
"https://www.google.com/search?espv=1#q=banana");
EXPECT_TRUE(
browser()->toolbar_model()->WouldPerformSearchTermReplacement(false));
- EXPECT_EQ(ASCIIToUTF16("banana"),
- location_bar->GetLocationEntry()->GetText());
+ EXPECT_EQ(base::ASCIIToUTF16("banana"), omnibox_view->GetText());
// Verify that searching from the omnibox does search term replacement with
// standard search URL pattern.
"https://www.google.com/search?q=tractor+parts&espv=1");
EXPECT_TRUE(
browser()->toolbar_model()->WouldPerformSearchTermReplacement(false));
- EXPECT_EQ(ASCIIToUTF16("tractor parts"),
- location_bar->GetLocationEntry()->GetText());
+ EXPECT_EQ(base::ASCIIToUTF16("tractor parts"), omnibox_view->GetText());
// Verify that searching from the omnibox prioritizes hash over query.
chrome::FocusLocationBar(browser());
"https://www.google.com/search?q=tractor+parts&espv=1#q=foobar");
EXPECT_TRUE(
browser()->toolbar_model()->WouldPerformSearchTermReplacement(false));
- EXPECT_EQ(ASCIIToUTF16("foobar"),
- location_bar->GetLocationEntry()->GetText());
+ EXPECT_EQ(base::ASCIIToUTF16("foobar"), omnibox_view->GetText());
}
-// The linux and win bots can't create a GL context. http://crbug.com/103379
-#if defined(OS_MACOSX)
IN_PROC_BROWSER_TEST_F(PolicyTest, Disable3DAPIs) {
- ui_test_utils::NavigateToURL(browser(), GURL(content::kAboutBlankURL));
+ // This test assumes Gpu access.
+ if (!content::GpuDataManager::GetInstance()->GpuAccessAllowed(NULL))
+ return;
+
+ ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
// WebGL is enabled by default.
content::WebContents* contents =
browser()->tab_strip_model()->GetActiveWebContents();
EXPECT_TRUE(IsWebGLEnabled(contents));
// Disable with a policy.
PolicyMap policies;
- policies.Set(key::kDisable3DAPIs, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kDisable3DAPIs,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
// Crash and reload the tab to get a new renderer.
content::CrashTab(contents);
EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_RELOAD));
EXPECT_FALSE(IsWebGLEnabled(contents));
// Enable with a policy.
- policies.Set(key::kDisable3DAPIs, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kDisable3DAPIs,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
content::CrashTab(contents);
EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_RELOAD));
EXPECT_TRUE(IsWebGLEnabled(contents));
}
-#endif
IN_PROC_BROWSER_TEST_F(PolicyTest, DisableSpdy) {
// Verifies that SPDY can be disable by policy.
EXPECT_TRUE(net::HttpStreamFactory::spdy_enabled());
PolicyMap policies;
- policies.Set(key::kDisableSpdy, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kDisableSpdy,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
content::RunAllPendingInMessageLoop();
EXPECT_FALSE(net::HttpStreamFactory::spdy_enabled());
// Verify that it can be force-enabled too.
browser()->profile()->GetPrefs()->SetBoolean(prefs::kDisableSpdy, true);
- policies.Set(key::kDisableSpdy, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kDisableSpdy,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
content::RunAllPendingInMessageLoop();
EXPECT_TRUE(net::HttpStreamFactory::spdy_enabled());
// Now disable it with a policy.
base::ListValue disabled_plugins;
- disabled_plugins.Append(base::Value::CreateStringValue("*Flash*"));
+ disabled_plugins.Append(new base::StringValue("*Flash*"));
PolicyMap policies;
policies.Set(key::kDisabledPlugins, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, disabled_plugins.DeepCopy(), NULL);
// Disable all plugins.
base::ListValue disabled_plugins;
- disabled_plugins.Append(base::Value::CreateStringValue("*"));
+ disabled_plugins.Append(new base::StringValue("*"));
PolicyMap policies;
policies.Set(key::kDisabledPlugins, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, disabled_plugins.DeepCopy(), NULL);
// Now open an exception for flash.
base::ListValue disabled_plugins_exceptions;
- disabled_plugins_exceptions.Append(
- base::Value::CreateStringValue("*Flash*"));
+ disabled_plugins_exceptions.Append(new base::StringValue("*Flash*"));
policies.Set(key::kDisabledPluginsExceptions, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, disabled_plugins_exceptions.DeepCopy(), NULL);
UpdateProviderPolicy(policies);
EXPECT_TRUE(SetPluginEnabled(plugin_prefs, flash, false));
EXPECT_FALSE(plugin_prefs->IsPluginEnabled(*flash));
base::ListValue plugin_list;
- plugin_list.Append(base::Value::CreateStringValue(content::kFlashPluginName));
+ plugin_list.Append(new base::StringValue(content::kFlashPluginName));
PolicyMap policies;
policies.Set(key::kEnabledPlugins, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, plugin_list.DeepCopy(), NULL);
ui_test_utils::NavigateToURL(browser(), url);
// This should have triggered the dangerous plugin infobar.
ASSERT_EQ(1u, infobar_service->infobar_count());
- EXPECT_TRUE(infobar_service->infobar_at(0)->AsConfirmInfoBarDelegate());
+ EXPECT_TRUE(
+ infobar_service->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate());
// And the plugin isn't running.
EXPECT_EQ(0, CountPlugins());
// Now set a policy to always authorize this.
PolicyMap policies;
- policies.Set(key::kAlwaysAuthorizePlugins, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kAlwaysAuthorizePlugins,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
// Reloading the page shouldn't trigger the infobar this time.
ui_test_utils::NavigateToURL(browser(), url);
content::WebContents* contents =
browser()->tab_strip_model()->GetActiveWebContents();
DevToolsWindow *devtools_window =
- DevToolsWindow::GetDockedInstanceForInspectedTab(contents);
+ DevToolsWindow::GetInstanceForInspectedWebContents(contents);
EXPECT_TRUE(devtools_window);
// Disable devtools via policy.
PolicyMap policies;
- policies.Set(key::kDeveloperToolsDisabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kDeveloperToolsDisabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
content::WindowedNotificationObserver close_observer(
content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
- content::Source<content::WebContents>(devtools_window->web_contents()));
+ content::Source<content::WebContents>(
+ DevToolsWindowTesting::Get(devtools_window)->main_web_contents()));
UpdateProviderPolicy(policies);
// wait for devtools close
close_observer.Wait();
// The existing devtools window should have closed.
- EXPECT_FALSE(DevToolsWindow::GetDockedInstanceForInspectedTab(contents));
+ EXPECT_FALSE(DevToolsWindow::GetInstanceForInspectedWebContents(contents));
// And it's not possible to open it again.
EXPECT_FALSE(chrome::ExecuteCommand(browser(), IDC_DEV_TOOLS));
- EXPECT_FALSE(DevToolsWindow::GetDockedInstanceForInspectedTab(contents));
+ EXPECT_FALSE(DevToolsWindow::GetInstanceForInspectedWebContents(contents));
}
-IN_PROC_BROWSER_TEST_F(PolicyTest, WebStoreIconHidden) {
+// TODO(samarth): remove along with rest of NTP4 code.
+IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_WebStoreIconHidden) {
#if defined(OS_WIN) && defined(USE_ASH)
// Disable this test in Metro+Ash for now (http://crbug.com/262796).
if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
// Turn off the web store icons.
PolicyMap policies;
- policies.Set(key::kHideWebStoreIcon, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kHideWebStoreIcon,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
// The web store icons should now be hidden.
EXPECT_FALSE(ContainsVisibleElement(contents, "chrome-web-store-link"));
}
-// This policy isn't available on Chrome OS.
-#if !defined(OS_CHROMEOS)
IN_PROC_BROWSER_TEST_F(PolicyTest, DownloadDirectory) {
// Verifies that the download directory can be forced by policy.
// Verify that downloads end up on the default directory.
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
DownloadAndVerifyFile(browser(), initial_dir.path(), file);
- file_util::DieFileDie(initial_dir.path().Append(file), false);
+ base::DieFileDie(initial_dir.path().Append(file), false);
// Override the download directory with the policy and verify a download.
base::ScopedTempDir forced_dir;
ASSERT_TRUE(forced_dir.CreateUniqueTempDir());
PolicyMap policies;
- policies.Set(key::kDownloadDirectory, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kDownloadDirectory,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateStringValue(forced_dir.path().value()), NULL);
+ new base::StringValue(forced_dir.path().value()),
+ NULL);
UpdateProviderPolicy(policies);
DownloadAndVerifyFile(browser(), forced_dir.path(), file);
// Verify that the first download location wasn't affected.
EXPECT_FALSE(base::PathExists(initial_dir.path().Append(file)));
}
-#endif
IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionInstallBlacklistSelective) {
// Verifies that blacklisted extensions can't be installed.
ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true));
ASSERT_FALSE(service->GetExtensionById(kAdBlockCrxId, true));
base::ListValue blacklist;
- blacklist.Append(base::Value::CreateStringValue(kGoodCrxId));
+ blacklist.Append(new base::StringValue(kGoodCrxId));
PolicyMap policies;
policies.Set(key::kExtensionInstallBlacklist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true));
ASSERT_TRUE(service->GetExtensionById(kAdBlockCrxId, true));
base::ListValue blacklist;
- blacklist.Append(base::Value::CreateStringValue("*"));
+ blacklist.Append(new base::StringValue("*"));
PolicyMap policies;
policies.Set(key::kExtensionInstallBlacklist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true));
ASSERT_FALSE(service->GetExtensionById(kAdBlockCrxId, true));
base::ListValue blacklist;
- blacklist.Append(base::Value::CreateStringValue("*"));
+ blacklist.Append(new base::StringValue("*"));
base::ListValue whitelist;
- whitelist.Append(base::Value::CreateStringValue(kGoodCrxId));
+ whitelist.Append(new base::StringValue(kGoodCrxId));
PolicyMap policies;
policies.Set(key::kExtensionInstallBlacklist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
// Setting the forcelist extension should install "good_v1.crx".
base::ListValue forcelist;
- forcelist.Append(base::Value::CreateStringValue(base::StringPrintf(
- "%s;%s", kGoodCrxId, url.spec().c_str())));
+ forcelist.Append(new base::StringValue(
+ base::StringPrintf("%s;%s", kGoodCrxId, url.spec().c_str())));
PolicyMap policies;
policies.Set(key::kExtensionInstallForcelist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, forcelist.DeepCopy(), NULL);
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_EXTENSION_INSTALLED,
+ extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
content::NotificationService::AllSources());
UpdateProviderPolicy(policies);
observer.Wait();
extensions::ExtensionUpdater::CheckParams params;
params.install_immediately = true;
content::WindowedNotificationObserver update_observer(
- chrome::NOTIFICATION_EXTENSION_INSTALLED,
+ extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
content::NotificationService::AllSources());
updater->CheckNow(params);
update_observer.Wait();
// Wait until any background pages belonging to force-installed extensions
// have been loaded.
- ExtensionProcessManager* manager =
+ extensions::ProcessManager* manager =
extensions::ExtensionSystem::Get(browser()->profile())->process_manager();
- ExtensionProcessManager::ViewSet all_views = manager->GetAllViews();
- for (ExtensionProcessManager::ViewSet::const_iterator iter =
+ extensions::ProcessManager::ViewSet all_views = manager->GetAllViews();
+ for (extensions::ProcessManager::ViewSet::const_iterator iter =
all_views.begin();
iter != all_views.end();) {
if (!(*iter)->IsLoading()) {
BackgroundContentsService::
SetRestartDelayForForceInstalledAppsAndExtensionsForTesting(0);
content::WindowedNotificationObserver extension_crashed_observer(
- chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
+ extensions::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
content::NotificationService::AllSources());
content::WindowedNotificationObserver extension_loaded_observer(
- chrome::NOTIFICATION_EXTENSION_LOADED,
+ extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
content::NotificationService::AllSources());
extensions::ExtensionHost* extension_host =
extensions::ExtensionSystem::Get(browser()->profile())->
#define MAYBE_ExtensionInstallSources ExtensionInstallSources
#endif
IN_PROC_BROWSER_TEST_F(PolicyTest, MAYBE_ExtensionInstallSources) {
- CommandLine::ForCurrentProcess()->AppendSwitchASCII(
- switches::kAppsGalleryInstallAutoConfirmForTests, "accept");
+ ExtensionInstallPrompt::g_auto_confirm_for_tests =
+ ExtensionInstallPrompt::ACCEPT;
const GURL install_source_url(URLRequestMockHTTPJob::GetMockUrl(
base::FilePath(FILE_PATH_LITERAL("extensions/*"))));
const GURL referrer_url(URLRequestMockHTTPJob::GetMockUrl(
base::FilePath(FILE_PATH_LITERAL("policy/*"))));
+ base::ScopedTempDir download_directory;
+ ASSERT_TRUE(download_directory.CreateUniqueTempDir());
+ DownloadPrefs* download_prefs =
+ DownloadPrefs::FromBrowserContext(browser()->profile());
+ download_prefs->SetDownloadPath(download_directory.path());
+
const GURL download_page_url(URLRequestMockHTTPJob::GetMockUrl(base::FilePath(
FILE_PATH_LITERAL("policy/extension_install_sources_test.html"))));
ui_test_utils::NavigateToURL(browser(), download_page_url);
UpdateProviderPolicy(policies);
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_EXTENSION_INSTALLED,
+ extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
content::NotificationService::AllSources());
PerformClick(1, 0);
observer.Wait();
browser()->profile()->GetHomePage());
content::WebContents* contents =
browser()->tab_strip_model()->GetActiveWebContents();
- EXPECT_EQ(GURL(content::kAboutBlankURL), contents->GetURL());
+ EXPECT_EQ(GURL(url::kAboutBlankURL), contents->GetURL());
EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_HOME));
EXPECT_EQ(GURL(chrome::kChromeUIPolicyURL), contents->GetURL());
// Now override with policy.
PolicyMap policies;
- policies.Set(key::kHomepageLocation, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kHomepageLocation,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateStringValue(chrome::kChromeUICreditsURL),
+ new base::StringValue(chrome::kChromeUICreditsURL),
NULL);
UpdateProviderPolicy(policies);
EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_HOME));
content::WaitForLoadStop(contents);
EXPECT_EQ(GURL(chrome::kChromeUICreditsURL), contents->GetURL());
- policies.Set(key::kHomepageIsNewTabPage, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kHomepageIsNewTabPage,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_HOME));
content::WaitForLoadStop(contents);
- EXPECT_TRUE(chrome::IsNTPURL(contents->GetURL(),browser()->profile()));
+ EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), contents->GetURL());
}
IN_PROC_BROWSER_TEST_F(PolicyTest, IncognitoEnabled) {
EXPECT_EQ(1u, active_browser_list->size());
EXPECT_FALSE(BrowserList::IsOffTheRecordSessionActive());
PolicyMap policies;
- policies.Set(key::kIncognitoEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kIncognitoEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_FALSE(chrome::ExecuteCommand(browser(), IDC_NEW_INCOGNITO_WINDOW));
EXPECT_EQ(1u, active_browser_list->size());
EXPECT_FALSE(BrowserList::IsOffTheRecordSessionActive());
// Enable via policy and verify that incognito windows can be opened.
- policies.Set(key::kIncognitoEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kIncognitoEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_TRUE(chrome::ExecuteCommand(browser(), IDC_NEW_INCOGNITO_WINDOW));
EXPECT_EQ(2u, active_browser_list->size());
// Disable Javascript via policy.
PolicyMap policies;
- policies.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kJavascriptEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
// Reload the page.
- ui_test_utils::NavigateToURL(browser(), GURL(content::kAboutBlankURL));
+ ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
EXPECT_FALSE(IsJavascriptEnabled(contents));
// Developer tools still work when javascript is disabled.
EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEV_TOOLS));
EXPECT_TRUE(IsJavascriptEnabled(contents));
// The javascript content setting policy overrides the javascript policy.
- ui_test_utils::NavigateToURL(browser(), GURL(content::kAboutBlankURL));
+ ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
EXPECT_FALSE(IsJavascriptEnabled(contents));
- policies.Set(key::kDefaultJavaScriptSetting, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kDefaultJavaScriptSetting,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(CONTENT_SETTING_ALLOW), NULL);
+ new base::FundamentalValue(CONTENT_SETTING_ALLOW),
+ NULL);
UpdateProviderPolicy(policies);
- ui_test_utils::NavigateToURL(browser(), GURL(content::kAboutBlankURL));
+ ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
EXPECT_TRUE(IsJavascriptEnabled(contents));
}
+IN_PROC_BROWSER_TEST_F(PolicyTest, NetworkPrediction) {
+ PrefService* prefs = browser()->profile()->GetPrefs();
+
+ // Enabled by default.
+ EXPECT_TRUE(IsNetworkPredictionEnabled(prefs));
+
+ // Disable by old, deprecated policy.
+ PolicyMap policies;
+ policies.Set(key::kDnsPrefetchingEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
+ UpdateProviderPolicy(policies);
+
+ EXPECT_FALSE(IsNetworkPredictionEnabled(prefs));
+
+ // Enabled by new policy, this should override old one.
+ policies.Set(
+ key::kNetworkPredictionOptions,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(chrome_browser_net::NETWORK_PREDICTION_ALWAYS),
+ NULL);
+ UpdateProviderPolicy(policies);
+
+ EXPECT_TRUE(IsNetworkPredictionEnabled(prefs));
+}
+
IN_PROC_BROWSER_TEST_F(PolicyTest, SavingBrowserHistoryDisabled) {
// Verifies that browsing history is not saved.
PolicyMap policies;
- policies.Set(key::kSavingBrowserHistoryDisabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kSavingBrowserHistoryDisabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
GURL url = ui_test_utils::GetTestUrl(
base::FilePath(base::FilePath::kCurrentDirectory),
EXPECT_EQ(0u, enumerator1.urls().size());
// Now flip the policy and try again.
- policies.Set(key::kSavingBrowserHistoryDisabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kSavingBrowserHistoryDisabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
ui_test_utils::NavigateToURL(browser(), url);
// Verify that the navigation was saved in the history.
// http://crbug.com/241691 PolicyTest.TranslateEnabled is failing regularly.
IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_TranslateEnabled) {
+ // TODO(port): Test corresponding bubble translate UX: http://crbug.com/383235
+ if (TranslateService::IsTranslateBubbleEnabled())
+ return;
+
+ scoped_ptr<test::CldDataHarness> cld_data_scope =
+ test::CreateCldDataHarness();
+ ASSERT_NO_FATAL_FAILURE(cld_data_scope->Init());
+
// Verifies that translate can be forced enabled or disabled by policy.
// Get the InfoBarService, and verify that there are no infobars on startup.
// Force enable the translate feature.
PolicyMap policies;
- policies.Set(key::kTranslateEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kTranslateEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
// Instead of waiting for NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED, this test
// waits for NOTIFICATION_TAB_LANGUAGE_DETERMINED because that's what the
language_observer1.Wait();
// Verify the translation detected for this tab.
- TranslateTabHelper* translate_tab_helper =
- TranslateTabHelper::FromWebContents(contents);
- ASSERT_TRUE(translate_tab_helper);
- LanguageState& language_state = translate_tab_helper->language_state();
+ ChromeTranslateClient* chrome_translate_client =
+ ChromeTranslateClient::FromWebContents(contents);
+ ASSERT_TRUE(chrome_translate_client);
+ translate::LanguageState& language_state =
+ chrome_translate_client->GetLanguageState();
EXPECT_EQ("fr", language_state.original_language());
EXPECT_TRUE(language_state.page_needs_translation());
EXPECT_FALSE(language_state.translation_pending());
// Verify that the translate infobar showed up.
ASSERT_EQ(1u, infobar_service->infobar_count());
- InfoBarDelegate* infobar = infobar_service->infobar_at(0);
- TranslateInfoBarDelegate* translate_infobar_delegate =
- infobar->AsTranslateInfoBarDelegate();
+ infobars::InfoBar* infobar = infobar_service->infobar_at(0);
+ translate::TranslateInfoBarDelegate* translate_infobar_delegate =
+ infobar->delegate()->AsTranslateInfoBarDelegate();
ASSERT_TRUE(translate_infobar_delegate);
- EXPECT_EQ(TranslateInfoBarDelegate::BEFORE_TRANSLATE,
- translate_infobar_delegate->infobar_type());
+ EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
+ translate_infobar_delegate->translate_step());
EXPECT_EQ("fr", translate_infobar_delegate->original_language_code());
// Now force disable translate.
infobar_service->RemoveInfoBar(infobar);
EXPECT_EQ(0u, infobar_service->infobar_count());
- policies.Set(key::kTranslateEnabled, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kTranslateEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
// Navigating to the same URL now doesn't trigger an infobar.
content::WindowedNotificationObserver language_observer2(
}
// Verify that "bbb.com" opens before applying the blacklist.
- CheckCanOpenURL(browser(), kURLS[1]);
+ EXPECT_NO_FATAL_FAILURE(CheckCanOpenURL(browser(), kURLS[1]));
// Set a blacklist.
base::ListValue blacklist;
- blacklist.Append(base::Value::CreateStringValue("bbb.com"));
+ blacklist.Append(new base::StringValue("bbb.com"));
PolicyMap policies;
policies.Set(key::kURLBlacklist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
UpdateProviderPolicy(policies);
FlushBlacklistPolicy();
// All bbb.com URLs are blocked, and "aaa.com" is still unblocked.
- CheckCanOpenURL(browser(), kURLS[0]);
- for (size_t i = 1; i < arraysize(kURLS); ++i)
- CheckURLIsBlocked(browser(), kURLS[i]);
+ EXPECT_NO_FATAL_FAILURE(CheckCanOpenURL(browser(), kURLS[0]));
+ for (size_t i = 1; i < arraysize(kURLS); ++i) {
+ EXPECT_NO_FATAL_FAILURE(CheckURLIsBlocked(browser(), kURLS[i]));
+ }
// Whitelist some sites of bbb.com.
base::ListValue whitelist;
- whitelist.Append(base::Value::CreateStringValue("sub.bbb.com"));
- whitelist.Append(base::Value::CreateStringValue("bbb.com/policy"));
+ whitelist.Append(new base::StringValue("sub.bbb.com"));
+ whitelist.Append(new base::StringValue("bbb.com/policy"));
policies.Set(key::kURLWhitelist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, whitelist.DeepCopy(), NULL);
UpdateProviderPolicy(policies);
FlushBlacklistPolicy();
- CheckURLIsBlocked(browser(), kURLS[1]);
- CheckCanOpenURL(browser(), kURLS[2]);
- CheckCanOpenURL(browser(), kURLS[3]);
+ EXPECT_NO_FATAL_FAILURE(CheckURLIsBlocked(browser(), kURLS[1]));
+ EXPECT_NO_FATAL_FAILURE(CheckCanOpenURL(browser(), kURLS[2]));
+ EXPECT_NO_FATAL_FAILURE(CheckCanOpenURL(browser(), kURLS[3]));
{
base::RunLoop loop;
const std::string file_path1 = base_path + "title1.html";
const std::string file_path2 = folder_path + "basic.html";
- CheckCanOpenURL(browser(), file_path1.c_str());
- CheckCanOpenURL(browser(), file_path2.c_str());
+ EXPECT_NO_FATAL_FAILURE(CheckCanOpenURL(browser(), file_path1.c_str()));
+ EXPECT_NO_FATAL_FAILURE(CheckCanOpenURL(browser(), file_path2.c_str()));
// Set a blacklist for all the files.
base::ListValue blacklist;
- blacklist.Append(base::Value::CreateStringValue("file://*"));
+ blacklist.Append(new base::StringValue("file://*"));
PolicyMap policies;
policies.Set(key::kURLBlacklist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
UpdateProviderPolicy(policies);
FlushBlacklistPolicy();
- CheckURLIsBlocked(browser(), file_path1.c_str());
- CheckURLIsBlocked(browser(), file_path2.c_str());
+ EXPECT_NO_FATAL_FAILURE(CheckURLIsBlocked(browser(), file_path1.c_str()));
+ EXPECT_NO_FATAL_FAILURE(CheckURLIsBlocked(browser(), file_path2.c_str()));
// Replace the URLblacklist with disabling the file scheme.
blacklist.Remove(base::StringValue("file://*"), NULL);
FlushBlacklistPolicy();
PrefService* prefs = browser()->profile()->GetPrefs();
- const base::ListValue* list_url = prefs->GetList(prefs::kUrlBlacklist);
+ const base::ListValue* list_url = prefs->GetList(policy_prefs::kUrlBlacklist);
EXPECT_EQ(list_url->Find(base::StringValue("file://*")),
list_url->end());
base::ListValue disabledscheme;
- disabledscheme.Append(base::Value::CreateStringValue("file"));
+ disabledscheme.Append(new base::StringValue("file"));
policies.Set(key::kDisabledSchemes, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, disabledscheme.DeepCopy(), NULL);
UpdateProviderPolicy(policies);
FlushBlacklistPolicy();
- list_url = prefs->GetList(prefs::kUrlBlacklist);
+ list_url = prefs->GetList(policy_prefs::kUrlBlacklist);
EXPECT_NE(list_url->Find(base::StringValue("file://*")),
list_url->end());
// Whitelist one folder and blacklist an another just inside.
base::ListValue whitelist;
- whitelist.Append(base::Value::CreateStringValue(base_path));
+ whitelist.Append(new base::StringValue(base_path));
policies.Set(key::kURLWhitelist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, whitelist.DeepCopy(), NULL);
- blacklist.Append(base::Value::CreateStringValue(folder_path));
+ blacklist.Append(new base::StringValue(folder_path));
policies.Set(key::kURLBlacklist, POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
UpdateProviderPolicy(policies);
FlushBlacklistPolicy();
- CheckCanOpenURL(browser(), file_path1.c_str());
- CheckURLIsBlocked(browser(), file_path2.c_str());
+ EXPECT_NO_FATAL_FAILURE(CheckCanOpenURL(browser(), file_path1.c_str()));
+ EXPECT_NO_FATAL_FAILURE(CheckURLIsBlocked(browser(), file_path2.c_str()));
+}
+
+static bool IsMinSSLVersionTLS12(Profile* profile) {
+ scoped_refptr<net::SSLConfigService> config_service(
+ profile->GetSSLConfigService());
+ net::SSLConfig config;
+ config_service->GetSSLConfig(&config);
+ return config.version_min == net::SSL_PROTOCOL_VERSION_TLS1_2;
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, SSLVersionMin) {
+ PrefService* prefs = g_browser_process->local_state();
+
+ const std::string new_value("tls1.2");
+ const std::string default_value(prefs->GetString(prefs::kSSLVersionMin));
+
+ EXPECT_NE(default_value, new_value);
+ EXPECT_FALSE(IsMinSSLVersionTLS12(browser()->profile()));
+
+ PolicyMap policies;
+ policies.Set(key::kSSLVersionMin,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(new_value),
+ NULL);
+ UpdateProviderPolicy(policies);
+
+ EXPECT_TRUE(IsMinSSLVersionTLS12(browser()->profile()));
+}
+
+static bool IsMinSSLFallbackVersionTLS12(Profile* profile) {
+ scoped_refptr<net::SSLConfigService> config_service(
+ profile->GetSSLConfigService());
+ net::SSLConfig config;
+ config_service->GetSSLConfig(&config);
+ return config.version_fallback_min == net::SSL_PROTOCOL_VERSION_TLS1_2;
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, SSLVersionFallbackMin) {
+ PrefService* prefs = g_browser_process->local_state();
+
+ const std::string new_value("tls1.2");
+ const std::string default_value(
+ prefs->GetString(prefs::kSSLVersionFallbackMin));
+
+ EXPECT_NE(default_value, new_value);
+ EXPECT_FALSE(IsMinSSLFallbackVersionTLS12(browser()->profile()));
+
+ PolicyMap policies;
+ policies.Set(key::kSSLVersionFallbackMin,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(new_value),
+ NULL);
+ UpdateProviderPolicy(policies);
+
+ EXPECT_TRUE(IsMinSSLFallbackVersionTLS12(browser()->profile()));
}
#if !defined(OS_MACOSX)
IN_PROC_BROWSER_TEST_F(PolicyTest, FullscreenAllowedBrowser) {
PolicyMap policies;
policies.Set(key::kFullscreenAllowed,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(false), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
BrowserWindow* browser_window = browser()->window();
IN_PROC_BROWSER_TEST_F(PolicyTest, FullscreenAllowedApp) {
PolicyMap policies;
policies.Set(key::kFullscreenAllowed,
- POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(false), NULL);
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
const extensions::Extension* extension =
ASSERT_TRUE(extension);
// Launch an app that tries to open a fullscreen window.
- TestAddShellWindowObserver add_window_observer(
- apps::ShellWindowRegistry::Get(browser()->profile()));
+ TestAddAppWindowObserver add_window_observer(
+ extensions::AppWindowRegistry::Get(browser()->profile()));
OpenApplication(AppLaunchParams(browser()->profile(),
extension,
- extension_misc::LAUNCH_NONE,
+ extensions::LAUNCH_CONTAINER_NONE,
NEW_WINDOW));
- apps::ShellWindow* window = add_window_observer.WaitForShellWindow();
+ extensions::AppWindow* window = add_window_observer.WaitForAppWindow();
ASSERT_TRUE(window);
// Verify that the window is not in fullscreen mode.
EXPECT_FALSE(audio_handler->IsOutputMuted());
EXPECT_EQ(1, test_observer->output_mute_changed_count());
PolicyMap policies;
- policies.Set(key::kAudioOutputAllowed, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
+ policies.Set(key::kAudioOutputAllowed,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_TRUE(audio_handler->IsOutputMuted());
// This should not change the state now and should not trigger output mute
EXPECT_EQ(1, test_observer->output_mute_changed_count());
// Toggle back and observe if the output mute changed event is fired.
- policies.Set(key::kAudioOutputAllowed, POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kAudioOutputAllowed,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_FALSE(audio_handler->IsOutputMuted());
EXPECT_EQ(1, test_observer->output_mute_changed_count());
audio_handler->RemoveAudioObserver(test_observer.get());
}
-IN_PROC_BROWSER_TEST_F(PolicyTest, PRE_SessionLengthLimit) {
+// Disabled, see http://crbug.com/315308.
+IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_PRE_SessionLengthLimit) {
// Indicate that the session started 2 hours ago and no user activity has
// occurred yet.
g_browser_process->local_state()->SetInt64(
.ToInternalValue());
}
-IN_PROC_BROWSER_TEST_F(PolicyTest, SessionLengthLimit) {
+// Disabled, see http://crbug.com/315308.
+IN_PROC_BROWSER_TEST_F(PolicyTest, DISABLED_SessionLengthLimit) {
content::MockNotificationObserver observer;
content::NotificationRegistrar registrar;
registrar.Add(&observer,
EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _))
.Times(0);
PolicyMap policies;
- policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kSessionLengthLimit,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(kThreeHoursInMs),
+ new base::FundamentalValue(kThreeHoursInMs),
NULL);
UpdateProviderPolicy(policies);
base::RunLoop().RunUntilIdle();
// Decrease the session length limit to 1 hour. Verify that the session is
// terminated immediately.
EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _));
- policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kSessionLengthLimit,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(kOneHourInMs),
+ new base::FundamentalValue(kOneHourInMs),
NULL);
UpdateProviderPolicy(policies);
base::RunLoop().RunUntilIdle();
Mock::VerifyAndClearExpectations(&observer);
}
-IN_PROC_BROWSER_TEST_F(PolicyTest, PRE_WaitForInitialUserActivityUsatisfied) {
+// Disabled, see http://crbug.com/315308.
+IN_PROC_BROWSER_TEST_F(PolicyTest,
+ DISABLED_PRE_WaitForInitialUserActivityUsatisfied) {
// Indicate that the session started 2 hours ago and no user activity has
// occurred yet.
g_browser_process->local_state()->SetInt64(
.ToInternalValue());
}
-IN_PROC_BROWSER_TEST_F(PolicyTest, WaitForInitialUserActivityUsatisfied) {
+// Disabled, see http://crbug.com/315308.
+IN_PROC_BROWSER_TEST_F(PolicyTest,
+ DISABLED_WaitForInitialUserActivityUsatisfied) {
content::MockNotificationObserver observer;
content::NotificationRegistrar registrar;
registrar.Add(&observer,
// terminated.
EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _))
.Times(0);
- policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kSessionLengthLimit,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(kOneHourInMs),
+ new base::FundamentalValue(kOneHourInMs),
NULL);
UpdateProviderPolicy(policies);
base::RunLoop().RunUntilIdle();
Mock::VerifyAndClearExpectations(&observer);
}
-IN_PROC_BROWSER_TEST_F(PolicyTest, PRE_WaitForInitialUserActivitySatisfied) {
+// Disabled, see http://crbug.com/315308.
+IN_PROC_BROWSER_TEST_F(PolicyTest,
+ DISABLED_PRE_WaitForInitialUserActivitySatisfied) {
// Indicate that initial user activity in this session occurred 2 hours ago.
g_browser_process->local_state()->SetInt64(
prefs::kSessionStartTime,
true);
}
-IN_PROC_BROWSER_TEST_F(PolicyTest, WaitForInitialUserActivitySatisfied) {
+// Disabled, see http://crbug.com/315308.
+IN_PROC_BROWSER_TEST_F(PolicyTest,
+ DISABLED_WaitForInitialUserActivitySatisfied) {
content::MockNotificationObserver observer;
content::NotificationRegistrar registrar;
registrar.Add(&observer,
POLICY_SCOPE_USER,
new base::FundamentalValue(true),
NULL);
- policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kSessionLengthLimit,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(kThreeHoursInMs),
+ new base::FundamentalValue(kThreeHoursInMs),
NULL);
UpdateProviderPolicy(policies);
base::RunLoop().RunUntilIdle();
// Decrease the session length limit to 1 hour. Verify that the session is
// terminated immediately.
EXPECT_CALL(observer, Observe(chrome::NOTIFICATION_APP_TERMINATING, _, _));
- policies.Set(key::kSessionLengthLimit, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kSessionLengthLimit,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(kOneHourInMs),
+ new base::FundamentalValue(kOneHourInMs),
NULL);
UpdateProviderPolicy(policies);
base::RunLoop().RunUntilIdle();
// Verify that policy overrides the manual setting.
PolicyMap policies;
- policies.Set(key::kLargeCursorEnabled, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kLargeCursorEnabled,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(false), NULL);
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_FALSE(accessibility_manager->IsLargeCursorEnabled());
// Verify that policy overrides the manual setting.
PolicyMap policies;
- policies.Set(key::kSpokenFeedbackEnabled, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kSpokenFeedbackEnabled,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(false), NULL);
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_FALSE(accessibility_manager->IsSpokenFeedbackEnabled());
// Verify that policy overrides the manual setting.
PolicyMap policies;
- policies.Set(key::kHighContrastEnabled, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kHighContrastEnabled,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(false), NULL);
+ new base::FundamentalValue(false),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_FALSE(accessibility_manager->IsHighContrastEnabled());
// Verify that policy overrides the manual setting.
PolicyMap policies;
- policies.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kScreenMagnifierType,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(0), NULL);
+ new base::FundamentalValue(0),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_FALSE(magnification_manager->IsMagnifierEnabled());
// Verify that policy can enable the full-screen magnifier.
PolicyMap policies;
- policies.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY,
+ policies.Set(key::kScreenMagnifierType,
+ POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(ash::MAGNIFIER_FULL), NULL);
+ new base::FundamentalValue(ash::MAGNIFIER_FULL),
+ NULL);
UpdateProviderPolicy(policies);
EXPECT_EQ(ash::MAGNIFIER_FULL, magnification_manager->GetMagnifierType());
EXPECT_TRUE(magnification_manager->IsMagnifierEnabled());
EXPECT_TRUE(magnification_manager->IsMagnifierEnabled());
}
+IN_PROC_BROWSER_TEST_F(PolicyTest, AccessibilityVirtualKeyboardEnabled) {
+ // Verifies that the on-screen keyboard accessibility feature can be
+ // controlled through policy.
+ chromeos::AccessibilityManager* accessibility_manager =
+ chromeos::AccessibilityManager::Get();
+
+ // Manually enable the on-screen keyboard.
+ accessibility_manager->EnableVirtualKeyboard(true);
+ EXPECT_TRUE(accessibility_manager->IsVirtualKeyboardEnabled());
+
+ // Verify that policy overrides the manual setting.
+ PolicyMap policies;
+ policies.Set(key::kVirtualKeyboardEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
+ UpdateProviderPolicy(policies);
+ EXPECT_FALSE(accessibility_manager->IsVirtualKeyboardEnabled());
+
+ // Verify that the on-screen keyboard cannot be enabled manually anymore.
+ accessibility_manager->EnableVirtualKeyboard(true);
+ EXPECT_FALSE(accessibility_manager->IsVirtualKeyboardEnabled());
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, VirtualKeyboardEnabled) {
+ // Verify keyboard disabled by default.
+ EXPECT_FALSE(keyboard::IsKeyboardEnabled());
+ // Verify keyboard can be toggled by default.
+ keyboard::SetTouchKeyboardEnabled(true);
+ EXPECT_TRUE(keyboard::IsKeyboardEnabled());
+ keyboard::SetTouchKeyboardEnabled(false);
+ EXPECT_FALSE(keyboard::IsKeyboardEnabled());
+
+ // Verify enabling the policy takes effect immediately and that that user
+ // cannot disable the keyboard..
+ PolicyMap policies;
+ policies.Set(key::kTouchVirtualKeyboardEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
+ UpdateProviderPolicy(policies);
+ EXPECT_TRUE(keyboard::IsKeyboardEnabled());
+ keyboard::SetTouchKeyboardEnabled(false);
+ EXPECT_TRUE(keyboard::IsKeyboardEnabled());
+
+ // Verify that disabling the policy takes effect immediately and that the user
+ // cannot enable the keyboard.
+ policies.Set(key::kTouchVirtualKeyboardEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
+ UpdateProviderPolicy(policies);
+ EXPECT_FALSE(keyboard::IsKeyboardEnabled());
+ keyboard::SetTouchKeyboardEnabled(true);
+ EXPECT_FALSE(keyboard::IsKeyboardEnabled());
+}
+
#endif
namespace {
command_line->InitFromArgv(argv);
ASSERT_TRUE(std::equal(argv.begin(), argv.end(),
command_line->argv().begin()));
+ }
- // Redirect the test URLs to the test data directory.
- RedirectHostsToTestData(kRestoredURLs, arraysize(kRestoredURLs));
+ virtual void SetUpOnMainThread() OVERRIDE {
+ BrowserThread::PostTask(
+ BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(
+ RedirectHostsToTestData, kRestoredURLs, arraysize(kRestoredURLs)));
}
void HomepageIsNotNTP() {
// the homepage is not the NTP.
PolicyMap policies;
policies.Set(
- key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(
- SessionStartupPref::kPrefValueHomePage),
+ key::kRestoreOnStartup,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage),
NULL);
- policies.Set(
- key::kHomepageIsNewTabPage, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(false), NULL);
- policies.Set(
- key::kHomepageLocation, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue(kRestoredURLs[1]), NULL);
+ policies.Set(key::kHomepageIsNewTabPage,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
+ policies.Set(key::kHomepageLocation,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue(kRestoredURLs[1]),
+ NULL);
provider_.UpdateChromePolicy(policies);
expected_urls_.push_back(GURL(kRestoredURLs[1]));
// the homepage is the NTP.
PolicyMap policies;
policies.Set(
- key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(
- SessionStartupPref::kPrefValueHomePage),
+ key::kRestoreOnStartup,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage),
NULL);
- policies.Set(
- key::kHomepageIsNewTabPage, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(true), NULL);
+ policies.Set(key::kHomepageIsNewTabPage,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
provider_.UpdateChromePolicy(policies);
expected_urls_.push_back(GURL(chrome::kChromeUINewTabURL));
// Verifies that policy can set the startup pages to a list of URLs.
base::ListValue urls;
for (size_t i = 0; i < arraysize(kRestoredURLs); ++i) {
- urls.Append(base::Value::CreateStringValue(kRestoredURLs[i]));
+ urls.Append(new base::StringValue(kRestoredURLs[i]));
expected_urls_.push_back(GURL(kRestoredURLs[i]));
}
PolicyMap policies;
- policies.Set(
- key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(SessionStartupPref::kPrefValueURLs),
- NULL);
+ policies.Set(key::kRestoreOnStartup,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(SessionStartupPref::kPrefValueURLs),
+ NULL);
policies.Set(
key::kRestoreOnStartupURLs, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
urls.DeepCopy(), NULL);
// Verifies that policy can set the startup page to the NTP.
PolicyMap policies;
policies.Set(
- key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(SessionStartupPref::kPrefValueNewTab),
+ key::kRestoreOnStartup,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(SessionStartupPref::kPrefValueNewTab),
NULL);
provider_.UpdateChromePolicy(policies);
expected_urls_.push_back(GURL(chrome::kChromeUINewTabURL));
void Last() {
// Verifies that policy can set the startup pages to the last session.
PolicyMap policies;
- policies.Set(
- key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateIntegerValue(SessionStartupPref::kPrefValueLast),
- NULL);
+ policies.Set(key::kRestoreOnStartup,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(SessionStartupPref::kPrefValueLast),
+ NULL);
provider_.UpdateChromePolicy(policies);
// This should restore the tabs opened at PRE_RunTest below.
for (size_t i = 0; i < arraysize(kRestoredURLs); ++i)
content::NOTIFICATION_LOAD_STOP,
content::NotificationService::AllSources());
chrome::AddSelectedTabWithURL(browser(), GURL(kRestoredURLs[i]),
- content::PAGE_TRANSITION_LINK);
+ ui::PAGE_TRANSITION_LINK);
observer.Wait();
}
}
virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
PolicyTest::SetUpInProcessBrowserTestFixture();
PolicyMap policies;
- policies.Set(
- key::kShowHomeButton, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(true), NULL);
- policies.Set(
- key::kBookmarkBarEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(false), NULL);
- policies.Set(
- key::kHomepageLocation, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateStringValue("http://chromium.org"), NULL);
+ policies.Set(key::kShowHomeButton,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(true),
+ NULL);
+ policies.Set(key::kBookmarkBarEnabled,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(false),
+ NULL);
+ policies.Set(key::kHomepageLocation,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue("http://chromium.org"),
+ NULL);
provider_.UpdateChromePolicy(policies);
}
};
// CompleteInitialization() task has executed as well.
content::RunAllPendingInMessageLoop();
- GURL kAboutHistograms = GURL(std::string(chrome::kAboutScheme) +
- std::string(content::kStandardSchemeSeparator) +
+ GURL kAboutHistograms = GURL(std::string(url::kAboutScheme) +
+ std::string(url::kStandardSchemeSeparator) +
std::string(content::kChromeUIHistogramHost));
ui_test_utils::NavigateToURL(browser(), kAboutHistograms);
content::WebContents* contents =
void ConfigurePolicyMap(PolicyMap* policies, const char* policy_name,
const char* whitelist_policy,
const char* allow_rule) {
- policies->Set(policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
- base::Value::CreateBooleanValue(policy_value_), NULL);
+ policies->Set(policy_name,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::FundamentalValue(policy_value_),
+ NULL);
if (whitelist_policy) {
// TODO(tommi): Remove the kiosk mode flag when the whitelist is visible
}
void Accept(const content::MediaStreamDevices& devices,
+ content::MediaStreamRequestResult result,
scoped_ptr<content::MediaStreamUI> ui) {
if (policy_value_ || request_url_allowed_via_whitelist_) {
ASSERT_EQ(1U, devices.size());
}
void FinishAudioTest() {
- content::MediaStreamRequest request(0, 0, 0, std::string(),
- request_url_.GetOrigin(),
+ content::MediaStreamRequest request(0, 0, 0,
+ request_url_.GetOrigin(), false,
content::MEDIA_DEVICE_ACCESS,
std::string(), std::string(),
content::MEDIA_DEVICE_AUDIO_CAPTURE,
void FinishVideoTest() {
// TODO(raymes): Test MEDIA_DEVICE_OPEN (Pepper) which grants both webcam
// and microphone permissions at the same time.
- content::MediaStreamRequest request(0, 0, 0, std::string(),
- request_url_.GetOrigin(),
+ content::MediaStreamRequest request(0, 0, 0,
+ request_url_.GetOrigin(), false,
content::MEDIA_DEVICE_ACCESS,
std::string(),
std::string(),
content::BrowserThread::PostTaskAndReply(
content::BrowserThread::IO, FROM_HERE,
- base::Bind(&MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged,
+ base::Bind(&MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices,
base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
audio_devices),
base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishAudioTest,
content::BrowserThread::PostTaskAndReply(
content::BrowserThread::IO, FROM_HERE,
base::Bind(
- &MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged,
+ &MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices,
base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
audio_devices),
base::Bind(
content::BrowserThread::PostTaskAndReply(
content::BrowserThread::IO, FROM_HERE,
- base::Bind(&MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged,
+ base::Bind(&MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices,
base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
video_devices),
base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishVideoTest,
content::BrowserThread::PostTaskAndReply(
content::BrowserThread::IO, FROM_HERE,
- base::Bind(
- &MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged,
+ base::Bind(&MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices,
base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
video_devices),
base::Bind(
virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
PolicyTest::SetUpInProcessBrowserTestFixture();
PolicyMap policies;
- policies.Set(
- key::kVariationsRestrictParameter,
- POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER,
- base::Value::CreateStringValue("restricted"),
- NULL);
+ policies.Set(key::kVariationsRestrictParameter,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ new base::StringValue("restricted"),
+ NULL);
provider_.UpdateChromePolicy(policies);
}
};
EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
EXPECT_EQ("restricted", value);
}
-#endif
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, NativeMessagingBlacklistSelective) {
+ base::ListValue blacklist;
+ blacklist.Append(new base::StringValue("host.name"));
+ PolicyMap policies;
+ policies.Set(key::kNativeMessagingBlacklist, POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
+ UpdateProviderPolicy(policies);
+
+ PrefService* prefs = browser()->profile()->GetPrefs();
+ EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed(
+ prefs, "host.name"));
+ EXPECT_TRUE(extensions::NativeMessageProcessHost::IsHostAllowed(
+ prefs, "other.host.name"));
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, NativeMessagingBlacklistWildcard) {
+ base::ListValue blacklist;
+ blacklist.Append(new base::StringValue("*"));
+ PolicyMap policies;
+ policies.Set(key::kNativeMessagingBlacklist, POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
+ UpdateProviderPolicy(policies);
+
+ PrefService* prefs = browser()->profile()->GetPrefs();
+ EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed(
+ prefs, "host.name"));
+ EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed(
+ prefs, "other.host.name"));
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, NativeMessagingWhitelist) {
+ base::ListValue blacklist;
+ blacklist.Append(new base::StringValue("*"));
+ base::ListValue whitelist;
+ whitelist.Append(new base::StringValue("host.name"));
+ PolicyMap policies;
+ policies.Set(key::kNativeMessagingBlacklist, POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
+ policies.Set(key::kNativeMessagingWhitelist, POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER, whitelist.DeepCopy(), NULL);
+ UpdateProviderPolicy(policies);
+
+ PrefService* prefs = browser()->profile()->GetPrefs();
+ EXPECT_TRUE(extensions::NativeMessageProcessHost::IsHostAllowed(
+ prefs, "host.name"));
+ EXPECT_FALSE(extensions::NativeMessageProcessHost::IsHostAllowed(
+ prefs, "other.host.name"));
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest,
+ EnableDeprecatedWebPlatformFeatures_ShowModalDialog) {
+ base::ListValue enabled_features;
+ enabled_features.Append(new base::StringValue(
+ "ShowModalDialog_EffectiveUntil20150430"));
+ PolicyMap policies;
+ policies.Set(key::kEnableDeprecatedWebPlatformFeatures,
+ POLICY_LEVEL_MANDATORY,
+ POLICY_SCOPE_USER,
+ enabled_features.DeepCopy(),
+ NULL);
+ UpdateProviderPolicy(policies);
+
+ // Policy only takes effect on new browsers, not existing browsers, so create
+ // a new browser.
+ Browser* browser2 = CreateBrowser(browser()->profile());
+ ui_test_utils::NavigateToURL(browser2, GURL(url::kAboutBlankURL));
+ bool result = false;
+ EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+ browser2->tab_strip_model()->GetActiveWebContents(),
+ "domAutomationController.send(window.showModalDialog !== undefined);",
+ &result));
+ EXPECT_TRUE(result);
+}
+
+#endif // !defined(CHROME_OS)
} // namespace policy
projects / platform / framework / web / crosswalk.git / blobdiff