Restructure SDCH layering to allow more separation (observer/1->[0,n]

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 "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "crypto/sha2.h"
 #include "net/base/sdch_manager.h"
+#include "net/base/sdch_observer.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sdch/open-vcdiff/src/google/vcencoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 205 matching lines @@
   bool cache_sdch_response_;
   std::string encoded_data_;
   std::string sdch_dictionary_contents_;
   std::string dictionary_client_hash_;
   std::string dictionary_server_hash_;
   RequestVector request_vector_;
   std::vector<base::Closure> callback_vector_;
   base::WeakPtrFactory<SdchResponseHandler> weak_ptr_factory_;
 };
 
-class SdchBrowserTest : public InProcessBrowserTest, net::URLFetcherDelegate {
+class SdchBrowserTest : public InProcessBrowserTest,
+                        public net::URLFetcherDelegate,
+                        public net::SdchObserver {
  public:
   static const char kTestHost[];
 
   SdchBrowserTest()
       : response_handler_(kTestHost),
         url_request_context_getter_(NULL),
         url_fetch_complete_(false),
         waiting_(false) {}
 
   // Helper functions for fetching data.
@@ skipping 71 matching lines @@
     return GetDataDetailed(url_request_context_getter_.get(),
                            sdch_encoding_used);
   }
 
   // Client information and control.
 
   int GetNumberOfDictionaryFetches(Profile* profile) {
     int fetches = -1;
     base::RunLoop run_loop;
     content::BrowserThread::PostTaskAndReply(
-        content::BrowserThread::IO, FROM_HERE,
+        content::BrowserThread::IO,
+        FROM_HERE,
         base::Bind(&SdchBrowserTest::GetNumberOfDictionaryFetchesOnIOThread,
+                   base::Unretained(this),
                    base::Unretained(profile->GetRequestContext()),
                    &fetches),
         run_loop.QuitClosure());
     run_loop.Run();
     DCHECK_NE(-1, fetches);
     return fetches;
   }
 
   void BrowsingDataRemoveAndWait(int remove_mask) {
     BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
@@ skipping 32 matching lines @@
         second_profile_, browser()->host_desktop_type()));
     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(
+        content::BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&SdchBrowserTest::SubscribeToSdchNotifications,
+                   base::Unretained(this),
+                   make_scoped_refptr(
+                       second_browser_->profile()->GetRequestContext())));
+
+    return true;
+  }
+
+  bool SetupIncognitoBrowser() {
+    incognito_browser_ = CreateIncognitoBrowser();
+
+    if (!incognito_browser_)
+      return false;
+
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&SdchBrowserTest::SubscribeToSdchNotifications,
+                   base::Unretained(this),
+                   make_scoped_refptr(
+                       incognito_browser_->profile()->GetRequestContext())));
+
     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) {
     base::RunLoop run_loop;
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
         base::Bind(&SdchResponseHandler::WaitAndGetRequestVector,
                    base::Unretained(&response_handler_),
                    num_requests,
@@ skipping 80 matching lines @@
  private:
   static void NukeSdchDictionariesOnIOThread(
       net::URLRequestContextGetter* context_getter) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
     net::SdchManager* sdch_manager =
         context_getter->GetURLRequestContext()->sdch_manager();
     DCHECK(sdch_manager);
     sdch_manager->ClearData();
   }
 
-  static void GetNumberOfDictionaryFetchesOnIOThread(
-      net::URLRequestContextGetter* url_request_context_getter,
+  void GetNumberOfDictionaryFetchesOnIOThread(
+      net::URLRequestContextGetter* context_getter,
       int* result) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    net::SdchManager* sdch_manager =
-        url_request_context_getter->GetURLRequestContext()->sdch_manager();
-    DCHECK(sdch_manager);
-    *result = sdch_manager->GetFetchesCountForTesting();
+
+    net::SdchManager* manager(
+        context_getter->GetURLRequestContext()->sdch_manager());
+    DCHECK(fetch_counts_.end() != fetch_counts_.find(manager));
+
+    *result = fetch_counts_[manager];
   }
 
   // InProcessBrowserTest
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(
         switches::kHostResolverRules,
         "MAP " + std::string(kTestHost) + " 127.0.0.1");
 #if defined(OS_CHROMEOS)
     command_line->AppendSwitch(
         chromeos::switches::kIgnoreUserProfileMappingForTests);
 #endif
   }
 
   void SetUpOnMainThread() override {
     test_server_.RegisterRequestHandler(
         base::Bind(&SdchResponseHandler::HandleRequest,
                    base::Unretained(&response_handler_)));
     CHECK(test_server_.InitializeAndWaitUntilReady());
     url_request_context_getter_ = browser()->profile()->GetRequestContext();
+
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&SdchBrowserTest::SubscribeToSdchNotifications,
+                   base::Unretained(this),
+                   url_request_context_getter_));
   }
 
   void TearDownOnMainThread() override {
     CHECK(test_server_.ShutdownAndWaitUntilComplete());
+
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&SdchBrowserTest::UnsubscribeFromAllSdchNotifications,
+                   base::Unretained(this)));
   }
 
+  void SubscribeToSdchNotifications(
+      net::URLRequestContextGetter* context_getter) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+
+    net::SdchManager* manager =
+        context_getter->GetURLRequestContext()->sdch_manager();
+    DCHECK(fetch_counts_.end() == fetch_counts_.find(manager));
+
+    fetch_counts_[manager] = 0;
+    manager->AddObserver(this);
+  }
+
+  void UnsubscribeFromAllSdchNotifications() {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+
+    for (auto it = fetch_counts_.begin(); it != fetch_counts_.end(); ++it)
+      it->first->RemoveObserver(this);
+
+    fetch_counts_.clear();
+  }
+
+  // SdchObserver
+  void OnGetDictionary(net::SdchManager* manager,
+                       const GURL& request_url,
+                       const GURL& dictionary_url) override {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+    DLOG(ERROR) << "Retrieving count of notifications from manager " << manager;
+    DCHECK(fetch_counts_.end() != fetch_counts_.find(manager));
+    ++fetch_counts_[manager];
+  }
+  void OnClearDictionaries(net::SdchManager* manager) override {}
+
   // URLFetcherDelegate
   void OnURLFetchComplete(const net::URLFetcher* source) override {
     url_fetch_complete_ = true;
     if (waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
   SdchResponseHandler response_handler_;
   net::test_server::EmbeddedTestServer test_server_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   scoped_ptr<net::URLFetcher> fetcher_;
   bool url_fetch_complete_;
   bool waiting_;
   base::ScopedTempDir second_profile_data_dir_;
   Profile* second_profile_;
   Browser* second_browser_;
+  Browser* incognito_browser_;
+
+  // IO Thread access only.
+  std::map<net::SdchManager*, int> fetch_counts_;
 };
 
 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) {
   ASSERT_TRUE(ForceSdchDictionaryLoad(browser()));
 
   // Confirm browsing data remover without removing the cache leaves
   // SDCH alone.
   BrowsingDataRemoveAndWait(BrowsingDataRemover::REMOVE_ALL &
                             ~BrowsingDataRemover::REMOVE_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::REMOVE_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) {
   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;
-  Browser* incognito_browser = CreateIncognitoBrowser();
-  EXPECT_TRUE(GetDataDetailed(
-      incognito_browser->profile()->GetRequestContext(),
-      &sdch_encoding_used));
+  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) {
-  Browser* incognito_browser = CreateIncognitoBrowser();
-  ASSERT_TRUE(ForceSdchDictionaryLoad(incognito_browser));
+  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