Add a SafeSearch preference, policy and implementation.

chrome/browser/policy/policy_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 61 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.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/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/download_test_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 "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
+#include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_stream_factory.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/plugins/npapi/plugin_utils.h"
@@ skipping 45 matching lines @@
   // Map the given hosts to the test data dir.
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
   for (size_t i = 0; i < size; ++i) {
     const GURL* url = urls[i];
     EXPECT_TRUE(url->is_valid());
     filter->AddHostnameHandler(url->scheme(), url->host(),
                                URLRequestMockHTTPJob::Factory);
   }
 }
 
+// Fails requests using ERR_CONNECTION_RESET.
+net::URLRequestJob* FailedJobFactory(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    const std::string& scheme) {
+  return new content::URLRequestFailedJob(
+      request, network_delegate, net::ERR_CONNECTION_RESET);
+}
+
+// Filters requests to the |host| such that they fail. Run on IO thread.
+void MakeRequestFailOnIO(const std::string& host) {
+  net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
+  filter->AddHostnameHandler("http", host, &FailedJobFactory);
+  filter->AddHostnameHandler("https", host, &FailedJobFactory);
+}
+
+// Sets up the filter on IO thread such that requests to |host| fail.
+void MakeRequestFail(const std::string& host) {
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(MakeRequestFailOnIO, host),
+      MessageLoop::QuitClosure());
+  content::RunMessageLoop();
+}
+
 // Verifies that the given |url| can be opened. This assumes that |url| points
 // at empty.html in the test data dir.
 void CheckCanOpenURL(Browser* browser, const GURL& url) {
   ui_test_utils::NavigateToURL(browser, url);
   content::WebContents* contents = chrome::GetActiveWebContents(browser);
   EXPECT_EQ(url, contents->GetURL());
   EXPECT_EQ(net::FormatUrl(url, std::string()), contents->GetTitle());
 }
 
 // Verifies that access to the given |url| is blocked.
@@ skipping 415 matching lines @@
                POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
   provider_.UpdateChromePolicy(policies);
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, ClearSiteDataOnExit) {
   // Verify that the cookie is gone.
   EXPECT_TRUE(GetCookies(browser()->profile(), GURL(kURL)).empty());
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultSearchProvider) {
+  MakeRequestFail("search.example");
+
   // 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 std::string kSearchURL("http://search.example/search?q={searchTerms}");
   const std::string kAlternateURL0(
       "http://search.example/search#q={searchTerms}");
   const std::string kAlternateURL1("http://search.example/#q={searchTerms}");
 
   TemplateURLService* service = TemplateURLServiceFactory::GetForProfile(
       browser()->profile());
@@ skipping 45 matching lines @@
                POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
   EXPECT_TRUE(service->GetDefaultSearchProvider());
   provider_.UpdateChromePolicy(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().destination_url.is_valid());
   EXPECT_EQ(GURL(chrome::kAboutBlankURL), web_contents->GetURL());
 }
 
+IN_PROC_BROWSER_TEST_F(PolicyTest, ForceSafeSearch) {
+  // Makes the requests fail since all we want to check is that the redirection
+  // is done properly.
+  MakeRequestFail("google.com");
+
+  // Verifies that requests to Google Search engine with the SafeSearch
+  // enabled set the safe=active&ssui=on parameters at the end of the query.
+  TemplateURLService* service = TemplateURLServiceFactory::GetForProfile(
+      browser()->profile());
+  ui_test_utils::WaitForTemplateURLServiceToLoad(service);
+
+  // First check that nothing happens.
+  content::TestNavigationObserver no_safesearch_observer(
+      content::NotificationService::AllSources());
+  chrome::FocusLocationBar(browser());
+  LocationBar* location_bar = browser()->window()->GetLocationBar();
+  ui_test_utils::SendToOmniboxAndSubmit(location_bar, "http://google.com/");
+  OmniboxEditModel* model = location_bar->GetLocationEntry()->model();
+  no_safesearch_observer.Wait();
+  EXPECT_TRUE(model->CurrentMatch().destination_url.is_valid());
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  GURL expected_without("http://google.com/");
+  EXPECT_EQ(expected_without, web_contents->GetURL());
+
+  PrefService* prefs = browser()->profile()->GetPrefs();
+  EXPECT_FALSE(prefs->IsManagedPreference(prefs::kForceSafeSearch));
+  EXPECT_FALSE(prefs->GetBoolean(prefs::kForceSafeSearch));
+
+  // Override the default SafeSearch setting using policies.
+  PolicyMap policies;
+  policies.Set(key::kForceSafeSearch, POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  provider_.UpdateChromePolicy(policies);
+
+  EXPECT_TRUE(prefs->IsManagedPreference(prefs::kForceSafeSearch));
+  EXPECT_TRUE(prefs->GetBoolean(prefs::kForceSafeSearch));
+
+  content::TestNavigationObserver safesearch_observer(
+      content::NotificationService::AllSources());
+
+  // 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().destination_url.is_valid());
+  web_contents = chrome::GetActiveWebContents(browser());
+  std::string expected_url("http://google.com/?");
+  expected_url += std::string(chrome::kSafeSearchSafeParameter) + "&" +
+                  chrome::kSafeSearchSsuiParameter;
+  GURL expected_with_parameters(expected_url);
+  EXPECT_EQ(expected_with_parameters, web_contents->GetURL());
+}
+
 IN_PROC_BROWSER_TEST_F(PolicyTest, ReplaceSearchTerms) {
+  MakeRequestFail("search.example");
+
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableInstantExtendedAPI);
 
   // Adding the kEnableInstantExtendedAPI is not enough since
   // IsInstantExtendedAPIEnabled does not return true on CHANNEL_DEV.
   if (!chrome::search::IsInstantExtendedAPIEnabled(browser()->profile()))
     return;
 
   // Verifies that a default search is made using the provider configured via
   // policy. Also checks that default search can be completely disabled.
@@ skipping 912 matching lines @@
   EXPECT_EQ(kExpectedLabel, text.substr(0, kExpectedLabel.size()));
   // HomepageLocation has policy ID 1.
   EXPECT_NE(std::string::npos, text.find("<br>1   ---"));
   // ShowHomeButton has policy ID 35.
   EXPECT_NE(std::string::npos, text.find("<br>35  ---"));
   // BookmarkBarEnabled has policy ID 82.
   EXPECT_NE(std::string::npos, text.find("<br>82  ---"));
 }
 
 }  // namespace policy