Enable SDCH over HTTPS.

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 "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // 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 {
  protected:
   SdchManagerTest()
-    : sdch_manager_(new SdchManager) {
+      : sdch_manager_(new SdchManager),
+        default_support_(false),
+        default_https_support_(false) {
+    default_support_ = sdch_manager_->sdch_enabled();
+    default_https_support_ = sdch_manager_->secure_scheme_supported();
   }
 
   SdchManager* sdch_manager() { return sdch_manager_.get(); }
 
   // Reset globals back to default state.
   virtual void TearDown() {
-    SdchManager::EnableSdchSupport(true);
-    SdchManager::EnableSecureSchemeSupport(false);
+    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);
   }
 
  private:
   scoped_ptr<SdchManager> sdch_manager_;
+  bool default_support_;
+  bool default_https_support_;
 };
 
 //------------------------------------------------------------------------------
 static std::string NewSdchDictionary(const std::string& domain) {
   std::string dictionary;
   if (!domain.empty()) {
     dictionary.append("Domain: ");
     dictionary.append(domain);
     dictionary.append("\n");
   }
@@ skipping 121 matching lines @@
   sdch_manager()->GetAvailDictionaryList(
       GURL("https://" + dictionary_domain + "/test"),
       &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 }
 
 TEST_F(SdchManagerTest, CanUseHTTPSDictionaryOverHTTPSIfEnabled) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
+  SdchManager::EnableSecureSchemeSupport(false);
   EXPECT_FALSE(AddSdchDictionary(dictionary_text,
                                  GURL("https://" + dictionary_domain)));
   SdchManager::EnableSecureSchemeSupport(true);
   EXPECT_TRUE(AddSdchDictionary(dictionary_text,
                                 GURL("https://" + dictionary_domain)));
 
   GURL target_url("https://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTPS target URL should advertise dictionary if secure scheme support is
   // enabled.
@@ skipping 255 matching lines @@
       GURL("http://" + dictionary_domain_1 + "/random_url"),
       &dictionary);
   EXPECT_FALSE(dictionary.get());
 }
 
 TEST_F(SdchManagerTest, HttpsCorrectlySupported) {
   GURL url("http://www.google.com");
   GURL secure_url("https://www.google.com");
 
   EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(url));
+  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(secure_url));
+
+  SdchManager::EnableSecureSchemeSupport(false);
+  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(url));
   EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(secure_url));
-
-  SdchManager::EnableSecureSchemeSupport(true);
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(url));
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(secure_url));
 }
 
 TEST_F(SdchManagerTest, ClearDictionaryData) {
   std::string dictionary_domain("x.y.z.google.com");
   GURL blacklist_url("http://bad.chromium.org");
 
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
   std::string tmp_hash;
   std::string server_hash;
 
@@ skipping 17 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));
 }
 
 }  // namespace net
-