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

net/base/sdch_manager_unittest.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.
 
 #include <limits.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/sdch_manager.h"
+#include "net/base/sdch_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // Workaround for http://crbug.com/418975; remove when fixed.
 #if !defined(OS_IOS)
 
 //------------------------------------------------------------------------------
 // Provide sample data and compression results with a sample VCDIFF dictionary.
 // Note an SDCH dictionary has extra meta-data before the VCDIFF dictionary.
 static const char kTestVcdiffDictionary[] = "DictionaryFor"
     "SdchCompression1SdchCompression2SdchCompression3SdchCompression\n";
 
 //------------------------------------------------------------------------------
 
-class SdchManagerTest : public testing::Test {
+class SdchManagerTest : public testing::Test, public SdchObserver {
  protected:
   SdchManagerTest()
       : sdch_manager_(new SdchManager),
         default_support_(false),
-        default_https_support_(false) {
+        default_https_support_(false),
+        get_dictionary_notifications_(0) {
     default_support_ = sdch_manager_->sdch_enabled();
     default_https_support_ = sdch_manager_->secure_scheme_supported();
+    sdch_manager_->AddObserver(this);
   }
 
+  virtual ~SdchManagerTest() { sdch_manager_->RemoveObserver(this); }
+
   SdchManager* sdch_manager() { return sdch_manager_.get(); }
 
   // Reset globals back to default state.
   void TearDown() override {
     SdchManager::EnableSdchSupport(default_support_);
     SdchManager::EnableSecureSchemeSupport(default_https_support_);
   }
 
   // Attempt to add a dictionary to the manager and probe for success or
   // failure.
   bool AddSdchDictionary(const std::string& dictionary_text,
                          const GURL& gurl) {
     std::string list;
     sdch_manager_->GetAvailDictionaryList(gurl, &list);
     sdch_manager_->AddSdchDictionary(dictionary_text, gurl);
     std::string list2;
     sdch_manager_->GetAvailDictionaryList(gurl, &list2);
 
     // The list of hashes should change iff the addition succeeds.
     return (list != list2);
   }
 
+  const GURL& last_dictionary_request_url() {
+    return last_dictionary_request_url_;
+  }
+  const GURL& last_dictionary_url() { return last_dictionary_url_; }
+  int get_dictionary_notifications() { return get_dictionary_notifications_; }
+
+  // SdchObserver implementation
+  void OnGetDictionary(SdchManager* manager,
+                       const GURL& request_url,
+                       const GURL& dictionary_url) override {
+    ++get_dictionary_notifications_;
+    last_dictionary_request_url_ = request_url;
+    last_dictionary_url_ = dictionary_url;
+  }
+  void OnClearDictionaries(SdchManager* manager) override {}
+
  private:
   scoped_ptr<SdchManager> sdch_manager_;
   bool default_support_;
   bool default_https_support_;
+  int get_dictionary_notifications_;
+  GURL last_dictionary_request_url_;
+  GURL last_dictionary_url_;
 };
 
 static std::string NewSdchDictionary(const std::string& domain) {
   std::string dictionary;
   if (!domain.empty()) {
     dictionary.append("Domain: ");
     dictionary.append(domain);
     dictionary.append("\n");
   }
   dictionary.append("\n");
@@ skipping 491 matching lines @@
 
   dictionary = NULL;
   sdch_manager()->GetVcdiffDictionary(
       server_hash,
       GURL("http://" + dictionary_domain + "/random_url"),
       &dictionary);
   EXPECT_FALSE(dictionary.get());
   EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(blacklist_url));
 }
 
+TEST_F(SdchManagerTest, GetDictionaryNotification) {

[Ryan Sleevi, 2014/11/05 22:21:39]

Pedantry: You don't test that _removing_ the observer causes no notifications to
be sent after removal.

[Randy Smith (Not in Mondays), 2014/11/05 23:49:59]

Good point.  Done.

+  GURL test_request_gurl(GURL("http://www.example.com/data"));
+  GURL test_dictionary_gurl(GURL("http://www.example.com/dict"));
+
+  EXPECT_EQ(0, get_dictionary_notifications());
+  sdch_manager()->OnGetDictionary(test_request_gurl, test_dictionary_gurl);
+  EXPECT_EQ(1, get_dictionary_notifications());
+  EXPECT_EQ(test_request_gurl, last_dictionary_request_url());
+  EXPECT_EQ(test_dictionary_gurl, last_dictionary_url());
+}
+
 #else
 
 TEST(SdchManagerTest, SdchOffByDefault) {
   GURL google_url("http://www.google.com");
   SdchManager* sdch_manager(new SdchManager);
 
   EXPECT_FALSE(sdch_manager->IsInSupportedDomain(google_url));
   SdchManager::EnableSdchSupport(true);
   EXPECT_TRUE(sdch_manager->IsInSupportedDomain(google_url));
 }
 
 #endif  // !defined(OS_IOS)
 
 }  // namespace net