SdchObserver: add OnDictionary{Added,Removed}

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 243 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 TestSdchObserver : public net::SdchObserver {
+ public:
+  TestSdchObserver() : manager_(nullptr), fetch_count_(0) {}
+  ~TestSdchObserver() override {
+    if (manager_) {
+      manager_->RemoveObserver(this);
+    }
+  }
+
+  void Observe(net::SdchManager* manager) {
+    DCHECK(!manager_);
+    manager_ = manager;
+    manager_->AddObserver(this);
+  }
+
+  // SdchObserver
+  void OnDictionaryAdded(const GURL& /* dictionary_url */,
+                         const std::string& /* server_hash */) override {}
+  void OnDictionaryRemoved(const std::string& /* server_hash */) override {}
+  void OnGetDictionary(const GURL& /* request_url */,
+                       const GURL& /* dictionary_url */) override {
+    fetch_count_++;
+  }
+  void OnDictionaryUsed(const std::string& /* server_hash */) override {}
+  void OnClearDictionaries() override {}
+
+  int fetch_count() const { return fetch_count_; }
+
+ private:
+  net::SdchManager* manager_;
+  int fetch_count_;

[mmenke, 2015/05/14 19:20:24]

nit:  DISALLOW_COPY_AND_ASSIGN

[Elly Fong-Jones, 2015/05/14 19:29:28]

This won't work, since this class is used as a value in an std::map below, which
requires elements to be assignable. Oh well :(

+};
+
 class SdchBrowserTest : public InProcessBrowserTest,
-                        public net::URLFetcherDelegate,
-                        public net::SdchObserver {
+                        public net::URLFetcherDelegate {
  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 264 matching lines @@
     sdch_manager->ClearData();
   }
 
   void GetNumberOfDictionaryFetchesOnIOThread(
       net::URLRequestContextGetter* context_getter,
       int* result) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
     net::SdchManager* manager(
         context_getter->GetURLRequestContext()->sdch_manager());
-    DCHECK(fetch_counts_.end() != fetch_counts_.find(manager));
+    DCHECK(observers_.end() != observers_.find(manager));
 
-    *result = fetch_counts_[manager];
+    *result = observers_[manager].fetch_count();
   }
 
   // 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);
@@ skipping 24 matching lines @@
         base::Bind(&SdchBrowserTest::UnsubscribeFromAllSdchNotifications,
                    base::Unretained(this)));
   }
 
   void SubscribeToSdchNotifications(
       net::URLRequestContextGetter* context_getter) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
     net::SdchManager* manager =
         context_getter->GetURLRequestContext()->sdch_manager();
-    DCHECK(fetch_counts_.end() == fetch_counts_.find(manager));
+    DCHECK(observers_.end() == observers_.find(manager));
 
-    fetch_counts_[manager] = 0;
-    manager->AddObserver(this);
+    observers_[manager].Observe(manager);
   }
 
   void UnsubscribeFromAllSdchNotifications() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-
-    for (auto it = fetch_counts_.begin(); it != fetch_counts_.end(); ++it)
-      it->first->RemoveObserver(this);
-
-    fetch_counts_.clear();
+    observers_.clear();
   }
 
-  // SdchObserver
-  void OnDictionaryUsed(net::SdchManager* manager,
-                        const std::string& server_hash) override {}
-
-  void OnGetDictionary(net::SdchManager* manager,
-                       const GURL& request_url,
-                       const GURL& dictionary_url) override {
-    DCHECK_CURRENTLY_ON(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_;
+  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) {
   ASSERT_TRUE(ForceSdchDictionaryLoad(browser()));
 
@@ skipping 37 matching lines @@
   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