Disable SDCH by Default

chrome/browser/net/sdch_browsertest.cc

 // Copyright 2014 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.
 
 // End-to-end SDCH tests.  Uses the embedded test server to return SDCH
 // results
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
@@ skipping 288 matching lines @@
  private:
   net::SdchManager* manager_;
   int fetch_count_;
 };
 
 class SdchBrowserTest : public InProcessBrowserTest,
                         public net::URLFetcherDelegate {
  public:
   static const char kTestHost[];
 
-  SdchBrowserTest()
-      : response_handler_(kTestHost),
-        url_request_context_getter_(NULL),
-        url_fetch_complete_(false),
-        waiting_(false) {}
+  SdchBrowserTest() : response_handler_(kTestHost) {}
 
   // Helper functions for fetching data.
 
   void FetchUrlDetailed(GURL url, net::URLRequestContextGetter* getter) {
     url_fetch_complete_ = false;
     fetcher_ = net::URLFetcher::Create(url, net::URLFetcher::GET, this);
     fetcher_->SetRequestContext(getter);
     fetcher_->Start();
     if (!url_fetch_complete_) {
       waiting_ = true;
@@ skipping 124 matching lines @@
     second_browser_ = new Browser(Browser::CreateParams(second_profile_, true));
     if (!second_browser_) return false;
 
     chrome::AddSelectedTabWithURL(second_browser_,
                                   GURL(url::kAboutBlankURL),
                                   ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
     content::WaitForLoadStop(
         second_browser_->tab_strip_model()->GetActiveWebContents());
     second_browser_->window()->Show();
 
-    content::BrowserThread::PostTask(
+    bool sdch_enabled = false;
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&SdchBrowserTest::SubscribeToSdchNotifications,
-                   base::Unretained(this),
-                   base::RetainedRef(
-                       second_browser_->profile()->GetRequestContext())));
+        base::Bind(
+            &SdchBrowserTest::SubscribeToSdchNotifications,
+            base::Unretained(this),
+            base::RetainedRef(second_browser_->profile()->GetRequestContext()),
+            &sdch_enabled_),
+        run_loop.QuitClosure());
+    run_loop.Run();
+    DCHECK(sdch_enabled);
 
     return true;
   }
 
   bool SetupIncognitoBrowser() {
     incognito_browser_ = CreateIncognitoBrowser();
 
     if (!incognito_browser_)
       return false;
 
-    content::BrowserThread::PostTask(
+    bool sdch_enabled = false;
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
         content::BrowserThread::IO, FROM_HERE,
         base::Bind(&SdchBrowserTest::SubscribeToSdchNotifications,
                    base::Unretained(this),
                    base::RetainedRef(
-                       incognito_browser_->profile()->GetRequestContext())));
+                       incognito_browser_->profile()->GetRequestContext()),
+                   &sdch_enabled),
+        run_loop.QuitClosure());
+    run_loop.Run();
+    DCHECK(sdch_enabled);
 
     return true;
   }
 
   Browser* second_browser() { return second_browser_; }
   Browser* incognito_browser() { return incognito_browser_; }
 
   // Server information and control.
 
   void WaitAndGetTestVector(int num_requests, RequestVector* result) {
@@ skipping 76 matching lines @@
     // Confirm the request vector looks at this point as expected.
     WaitAndGetTestVector(4, &request_vector);
     EXPECT_EQ(4u, request_vector.size());
     EXPECT_EQ(request_vector[2].relative_url, kDataURLPath);
     EXPECT_EQ(request_vector[3].relative_url, kDataURLPath);
     return (4u == request_vector.size() &&
             request_vector[2].relative_url == kDataURLPath &&
             request_vector[3].relative_url == kDataURLPath);
   }
 
+  bool sdch_enabled() const { return sdch_enabled_; }
+
  private:
   static void NukeSdchDictionariesOnIOThread(
       net::URLRequestContextGetter* context_getter) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
     net::SdchManager* sdch_manager =
         context_getter->GetURLRequestContext()->sdch_manager();
     DCHECK(sdch_manager);
     sdch_manager->ClearData();
   }
 
@@ skipping 20 matching lines @@
 #endif
   }
 
   void SetUpOnMainThread() override {
     test_server_.RegisterRequestHandler(
         base::Bind(&SdchResponseHandler::HandleRequest,
                    base::Unretained(&response_handler_)));
     CHECK(test_server_.Start());
     url_request_context_getter_ = browser()->profile()->GetRequestContext();
 
-    content::BrowserThread::PostTask(
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
         content::BrowserThread::IO, FROM_HERE,
         base::Bind(&SdchBrowserTest::SubscribeToSdchNotifications,
                    base::Unretained(this),
-                   base::RetainedRef(url_request_context_getter_)));
+                   base::RetainedRef(url_request_context_getter_),
+                   &sdch_enabled_),
+        run_loop.QuitClosure());
+    run_loop.Run();
   }
 
   void TearDownOnMainThread() override {
     CHECK(test_server_.ShutdownAndWaitUntilComplete());
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(&SdchBrowserTest::UnsubscribeFromAllSdchNotifications,
                    base::Unretained(this)));
   }
 
+  // Check if SDCH is enabled, and if so subscribe an observer to the
+  // SDCH manager on the URLRequestContext that was passed in.
   void SubscribeToSdchNotifications(
-      net::URLRequestContextGetter* context_getter) {
+      net::URLRequestContextGetter* context_getter,
+      bool* sdch_enabled) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
     net::SdchManager* manager =
         context_getter->GetURLRequestContext()->sdch_manager();
+    *sdch_enabled = !!manager;
+    if (!*sdch_enabled)
+      return;
+
     DCHECK(observers_.end() == observers_.find(manager));
 
     observers_[manager].Observe(manager);
   }
 
   void UnsubscribeFromAllSdchNotifications() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
     observers_.clear();
   }
 
   // URLFetcherDelegate
   void OnURLFetchComplete(const net::URLFetcher* source) override {
     url_fetch_complete_ = true;
     if (waiting_)
       base::MessageLoopForUI::current()->QuitWhenIdle();
   }
 
+  bool sdch_enabled_ = false;
   SdchResponseHandler response_handler_;
   net::EmbeddedTestServer test_server_;
-  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_ =
+      nullptr;
   std::unique_ptr<net::URLFetcher> fetcher_;
-  bool url_fetch_complete_;
-  bool waiting_;
+  bool url_fetch_complete_ = false;
+  bool waiting_ = false;
   base::ScopedTempDir second_profile_data_dir_;
   Profile* second_profile_;
   Browser* second_browser_;
   Browser* incognito_browser_;
 
   // IO Thread access only.
   std::map<net::SdchManager*, TestSdchObserver> observers_;
 };
 
 const char SdchBrowserTest::kTestHost[] = "our.test.host.com";
 
 // Confirm that after getting a dictionary, calling the browsing
 // data remover renders it unusable.  Also (in calling
 // ForceSdchDictionaryLoad()) servers as a smoke test for SDCH.
 IN_PROC_BROWSER_TEST_F(SdchBrowserTest, BrowsingDataRemover) {
+  if (!sdch_enabled()) {
+    LOG(ERROR) << "SDCH disabled; not running test.";
+    return;
+  }
+
   ASSERT_TRUE(ForceSdchDictionaryLoad(browser()));
 
   // Confirm browsing data remover without removing the cache leaves
   // SDCH alone.
   BrowsingDataRemoveAndWait(ChromeBrowsingDataRemoverDelegate::ALL_DATA_TYPES &
                             ~BrowsingDataRemover::DATA_TYPE_CACHE);
   bool sdch_encoding_used = false;
   ASSERT_TRUE(GetData(&sdch_encoding_used));
   EXPECT_TRUE(sdch_encoding_used);
 
   // Confirm browsing data remover removing the cache clears SDCH state.
   BrowsingDataRemoveAndWait(BrowsingDataRemover::DATA_TYPE_CACHE);
   sdch_encoding_used = false;
   ASSERT_TRUE(GetData(&sdch_encoding_used));
   EXPECT_FALSE(sdch_encoding_used);
 }
 
 // Confirm dictionaries not visible in other profiles.
 IN_PROC_BROWSER_TEST_F(SdchBrowserTest, Isolation) {
+  if (!sdch_enabled()) {
+    LOG(ERROR) << "SDCH disabled; not running test.";
+    return;
+  }
+
   ASSERT_TRUE(ForceSdchDictionaryLoad(browser()));
   ASSERT_TRUE(SetupSecondBrowser());
   ASSERT_TRUE(SetupIncognitoBrowser());
 
   // Data fetches from incognito or separate profiles should not be SDCH
   // encoded.
   bool sdch_encoding_used = true;
   EXPECT_TRUE(
       GetDataDetailed(incognito_browser()->profile()->GetRequestContext(),
                       &sdch_encoding_used));
   EXPECT_FALSE(sdch_encoding_used);
 
   sdch_encoding_used = true;
   EXPECT_TRUE(GetDataDetailed(
       second_browser()->profile()->GetRequestContext(), &sdch_encoding_used));
   EXPECT_FALSE(sdch_encoding_used);
 }
 
 // Confirm a dictionary loaded in incognito isn't visible in the main profile.
 IN_PROC_BROWSER_TEST_F(SdchBrowserTest, ReverseIsolation) {
+  if (!sdch_enabled()) {
+    LOG(ERROR) << "SDCH disabled; not running test.";
+    return;
+  }
+
   ASSERT_TRUE(SetupIncognitoBrowser());
   ASSERT_TRUE(ForceSdchDictionaryLoad(incognito_browser()));
 
   // Data fetches on main browser should not be SDCH encoded.
   bool sdch_encoding_used = true;
   ASSERT_TRUE(GetData(&sdch_encoding_used));
   EXPECT_FALSE(sdch_encoding_used);
 }
 
 }  // namespace