Add a SafeSearch preference, policy and implementation.

chrome/browser/net/chrome_network_delegate_unittest.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 "chrome/browser/net/chrome_network_delegate.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/api/prefs/pref_member.h"
 #include "chrome/browser/extensions/event_router_forwarder.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/url_constants.h"
+#include "chrome/test/base/testing_pref_service.h"
+#include "chrome/test/base/testing_profile.h"
+#include "net/base/completion_callback.h"
+#include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+const std::string kSafeParameter = chrome::kSafeSearchSafeParameter;
+const std::string kSsuiParameter = chrome::kSafeSearchSsuiParameter;
+const std::string kBothParameters = kSafeParameter + "&" + kSsuiParameter;

[Joao da Silva, 2012/10/19 10:00:38]

This requires a static initializer to call the string ctors. Move the string
constants to the SafeSearchOn test instead.

[Sergiu, 2012/10/19 12:00:18]

Done.

+}
+
 class ChromeNetworkDelegateTest : public testing::Test {
  protected:
   ChromeNetworkDelegateTest()
       : forwarder_(new extensions::EventRouterForwarder()) {
   }
 
   virtual void SetUp() OVERRIDE {
     never_throttle_requests_original_value_ =
         ChromeNetworkDelegate::g_never_throttle_requests_;
     ChromeNetworkDelegate::g_never_throttle_requests_ = false;
   }
 
   virtual void TearDown() OVERRIDE {
     ChromeNetworkDelegate::g_never_throttle_requests_ =
         never_throttle_requests_original_value_;
   }
 
   scoped_ptr<ChromeNetworkDelegate> CreateNetworkDelegate() {
     return scoped_ptr<ChromeNetworkDelegate>(new ChromeNetworkDelegate(
         forwarder_.get(), NULL, NULL, NULL, NULL, NULL, &pref_member_, NULL,
-        NULL));
+        NULL, NULL));
   }
 
   // Implementation moved here for access to private bits.
   void NeverThrottleLogicImpl() {
     scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 
     TestURLRequestContext context;
     TestURLRequest extension_request(
         GURL("http://example.com/"), NULL, &context);
     extension_request.set_first_party_for_cookies(
@@ skipping 27 matching lines @@
   bool never_throttle_requests_original_value_;
   MessageLoopForIO message_loop_;
 
   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
   BooleanPrefMember pref_member_;
 };
 
 TEST_F(ChromeNetworkDelegateTest, NeverThrottleLogic) {
   NeverThrottleLogicImpl();
 }
+
+class ChromeNetworkDelegateSafesearchTest : public testing::Test {
+ public:
+  scoped_ptr<net::NetworkDelegate> CreateNetworkDelegate() {
+    return scoped_ptr<net::NetworkDelegate>(new ChromeNetworkDelegate(
+        forwarder_.get(), NULL, NULL, NULL, NULL, NULL, &enable_referrers_,
+        NULL, &force_google_safesearch_, NULL));
+  }
+
+  void SetSafesearch(bool value) {
+    force_google_safesearch_.SetValue(value);
+  }
+
+  void SetDelegate(net::NetworkDelegate* delegate) {
+    context_.set_network_delegate(delegate);
+  }
+
+ protected:
+  ChromeNetworkDelegateSafesearchTest()
+      : forwarder_(new extensions::EventRouterForwarder()) {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    prefs_.RegisterBooleanPref(prefs::kForceSafeSearch, false,
+                               PrefService::UNSYNCABLE_PREF);
+    force_google_safesearch_.Init(prefs::kForceSafeSearch,
+                                  profile_.GetTestingPrefService(), NULL);
+    prefs_.RegisterBooleanPref(prefs::kEnableReferrers, false,
+                               PrefService::UNSYNCABLE_PREF);
+    enable_referrers_.Init(prefs::kEnableReferrers,
+                           profile_.GetTestingPrefService(), NULL);
+    loop_.reset(new MessageLoopForIO());
+  }
+
+  // Verifies that the expected string is equal to the query part (between
+  // ? and #) of the url_string.
+  void CheckAddedParameters(const std::string& url_string,
+                            std::string expected) {
+    // Show the URL in the trace so we know where we failed.
+    SCOPED_TRACE(url_string);
+
+    TestURLRequest request(GURL(url_string), &delegate_, &context_);
+
+    request.Start();
+    MessageLoop::current()->RunAllPending();
+
+    EXPECT_EQ(expected, request.url().query());
+  }
+
+ private:
+  scoped_refptr<extensions::EventRouterForwarder> forwarder_;
+  TestingProfile profile_;
+  TestingPrefService prefs_;
+  BooleanPrefMember enable_referrers_;
+  BooleanPrefMember force_google_safesearch_;
+  scoped_ptr<net::URLRequest> request_;
+  TestURLRequestContext context_;
+  TestDelegate delegate_;
+  scoped_ptr<MessageLoopForIO> loop_;
+};
+
+TEST_F(ChromeNetworkDelegateSafesearchTest, SafesearchOn) {
+  // Tests with SafeSearch on, request parameters should be rewritten.
+  SetSafesearch(true);
+  scoped_ptr<net::NetworkDelegate> delegate(CreateNetworkDelegate());
+  SetDelegate(delegate.get());
+
+  // Test the home page.
+  CheckAddedParameters("http://google.com/", kBothParameters);
+
+  // Test the search home page.
+  CheckAddedParameters("http://google.com/webhp",
+                       kBothParameters);
+
+  // Test different valid search pages with parameters.
+  CheckAddedParameters("http://google.com/search?q=google",
+                       "q=google&" + kBothParameters);
+
+  CheckAddedParameters("http://google.com/?q=google",
+                       "q=google&" + kBothParameters);
+
+  CheckAddedParameters("http://google.com/webhp?q=google",
+                       "q=google&" + kBothParameters);
+
+  // Test the valid pages with safe set to off.
+  CheckAddedParameters("http://google.com/search?q=google&safe=off",
+                       "q=google&" + kBothParameters);
+
+  CheckAddedParameters("http://google.com/?q=google&safe=off",
+                       "q=google&" + kBothParameters);
+
+  CheckAddedParameters("http://google.com/webhp?q=google&safe=off",
+                       "q=google&" + kBothParameters);
+
+  // Test the home page, different TLDs.
+  CheckAddedParameters("http://google.de/", kBothParameters);
+  CheckAddedParameters("http://google.ro/", kBothParameters);
+  CheckAddedParameters("http://google.nl/", kBothParameters);
+
+  // Test the search home page, different TLD.
+  CheckAddedParameters("http://google.de/webhp", kBothParameters);
+
+  // Test the home page with parameters, different TLD.
+  CheckAddedParameters("http://google.de/search?q=google",
+                       "q=google&" + kBothParameters);
+
+  // Test the search page with parameters, different TLD.
+  CheckAddedParameters("http://google.de/?q=google",
+                       "q=google&" + kBothParameters);
+
+  // Test the search page with the parameters set.
+  CheckAddedParameters("http://google.de/?q=google&" + kBothParameters,
+                       "q=google&" + kBothParameters);
+
+  // Test some possibly tricky combinations.
+  CheckAddedParameters("http://google.com/?q=goog&" + kSafeParameter +
+                       "&ssui=one",
+                       "q=goog&" + kBothParameters);
+
+  CheckAddedParameters("http://google.de/?q=goog&unsafe=active&" +
+                       kSsuiParameter,
+                       "q=goog&unsafe=active&" + kSsuiParameter + "&" +
+                       kSafeParameter);
+
+  CheckAddedParameters("http://google.de/?q=goog&safe=off&ssui=off",
+                       "q=goog&" + kSafeParameter + "&" + kSsuiParameter);
+
+  // Test various combinations where we should not add anything.
+  CheckAddedParameters("http://google.com/?q=goog&" + kSsuiParameter + "&" +
+                       kSafeParameter,
+                       "q=goog&" + kSsuiParameter + "&" + kSafeParameter);
+
+  CheckAddedParameters("http://google.com/?" + kSsuiParameter + "&q=goog&" +
+                       kSafeParameter,
+                       kSsuiParameter + "&q=goog&" + kSafeParameter);
+
+  CheckAddedParameters("http://google.com/?" + kSsuiParameter + "&" +
+                       kSafeParameter + "&q=goog",
+                       kSsuiParameter + "&" + kSafeParameter + "&q=goog");
+
+  // Test that another website is not affected, without parameters.
+  CheckAddedParameters("http://google.com/finance", "");
+
+  // Test that another website is not affected, with parameters.
+  CheckAddedParameters("http://google.com/finance?q=goog", "q=goog");
+
+  // Test that another website is not affected with redirects, with parameters.
+  CheckAddedParameters("http://finance.google.com/?q=goog", "q=goog");
+}
+
+TEST_F(ChromeNetworkDelegateSafesearchTest, SafesearchOff) {
+  // Tests with SafeSearch settings off, delegate should not alter requests.
+  SetSafesearch(false);
+  scoped_ptr<net::NetworkDelegate> delegate(CreateNetworkDelegate());
+  SetDelegate(delegate.get());
+
+  // Test the home page.
+  CheckAddedParameters("http://google.com/", "");
+
+  // Test the search home page.
+  CheckAddedParameters("http://google.com/webhp", "");
+
+  // Test the home page with parameters.
+  CheckAddedParameters("http://google.com/search?q=google",
+                       "q=google");
+
+  // Test the search page with parameters.
+  CheckAddedParameters("http://google.com/?q=google",
+                       "q=google");
+
+  // Test the search webhp page with parameters.
+  CheckAddedParameters("http://google.com/webhp?q=google",
+                       "q=google");
+
+  // Test the home page with parameters and safe set to off.
+  CheckAddedParameters("http://google.com/search?q=google&safe=off",
+                       "q=google&safe=off");
+
+  // Test the home page with parameters and safe set to active.
+  CheckAddedParameters("http://google.com/search?q=google&safe=active",
+                       "q=google&safe=active");
+}