Sdch view for net-internals

net/base/sdch_manager.h

Index: net/base/sdch_manager.h
diff --git a/net/base/sdch_manager.h b/net/base/sdch_manager.h
index f78f1dd43b51ece681e559c7f6cc8efca55191f6..a537043e9a7e5adafe5bdedc3a4db9b554af4ce8 100644
--- a/net/base/sdch_manager.h
+++ b/net/base/sdch_manager.h
@@ -32,8 +32,14 @@
 #include "net/base/net_export.h"
 #include "url/gurl.h"
 
+namespace base {
+class Value;
+}
+
 namespace net {
 
+class BoundNetLog;
+
 //------------------------------------------------------------------------------
 // Create a public interface to help us load SDCH dictionaries.
 // The SdchManager class allows registration to support this interface.
@@ -42,6 +48,12 @@ namespace net {
 // functionality in this base (when the functionality can be provided).
 class NET_EXPORT SdchFetcher {
  public:
+  enum ScheduleResult {

[Randy Smith (Not in Mondays), 2014/09/18 20:55:51]

So this (the enum, switching Schedule() to return the enum, and transforming the
enum into an SdchManager::ProblemCode at point of call) is a correct
transformation of the current code, but I don't think it's that useful from a
debugability point of view, and it's a lot of ugly boilerplate in several
places, so I'd like to skip it.  Part of the reason I don't think it's useful
from a debugability point of view is that I don't see a real distinction between
ALREADY_TRIED and ALREADY_SCHEDULED in SdchDictionaryFetcher::Schedule; they
both mean "yeah, I already took a shot at that dictionary, for better or worse"
(i.e. I think the existing code is broken).  

So I think I'd like to ask you to do a slight functionality change in this CL to
make the debugging implementation cleaner: Could you obsolete
DICTIONARY_ALREADY_SCHEDULED_TO_DOWNLOAD, and
DICTIONARY_ALREADY_TRIED_TO_DOWNLOAD and replace them with a new ProblemCode
(PREVIOUSLY_SCHEDULED?), and change Schedule() to return a bool indicating
whether the load was successfully scheduled, and turn a false return from that
function into the new ProblemCode?  That'll remove a lot of boilerplate.

[baranovich, 2014/09/19 12:42:44]

Sure, I'll try.

[baranovich, 2014/09/30 13:16:52]

Done.

+    SCHEDULE_OK,
+    ALREADY_SCHEDULED,
+    ALREADY_TRIED,
+  };
+
   class NET_EXPORT Delegate {
    public:
     virtual ~Delegate() {}
@@ -50,7 +62,8 @@ class NET_EXPORT SdchFetcher {
     // dictionary.  |dictionary_text| contains the body of the dictionary
     // retrieved from |dictionary_url|.
     virtual void AddSdchDictionary(const std::string& dictionary_text,
-                                   const GURL& dictionary_url) = 0;
+                                   const GURL& dictionary_url,
+                                   const BoundNetLog& net_log) = 0;
   };
 
   SdchFetcher() {}
@@ -59,7 +72,7 @@ class NET_EXPORT SdchFetcher {
   // The Schedule() method is called when there is a need to get a dictionary
   // from a server. The callee is responsible for getting that dictionary_text,
   // and then calling back to AddSdchDictionary() in the Delegate instance.
-  virtual void Schedule(const GURL& dictionary_url) = 0;
+  virtual ScheduleResult Schedule(const GURL& dictionary_url) = 0;
 
   // The Cancel() method is called to cancel all pending dictionary fetches.
   // This is used for implementation of ClearData() below.
@@ -78,100 +91,11 @@ class NET_EXPORT SdchManager
   // A list of errors that appeared and were either resolved, or used to turn
   // off sdch encoding.
   enum ProblemCodes {
-    MIN_PROBLEM_CODE,
-
-    // Content-encoding correction problems.
-    ADDED_CONTENT_ENCODING = 1,
-    FIXED_CONTENT_ENCODING = 2,
-    FIXED_CONTENT_ENCODINGS = 3,
-
-    // Content decoding errors.
-    DECODE_HEADER_ERROR = 4,
-    DECODE_BODY_ERROR = 5,
-
-    // More content-encoding correction problems.
-    OPTIONAL_GUNZIP_ENCODING_ADDED = 6,
-
-    // Content encoding correction when we're not even tagged as HTML!?!
-    BINARY_ADDED_CONTENT_ENCODING = 7,
-    BINARY_FIXED_CONTENT_ENCODING = 8,
-    BINARY_FIXED_CONTENT_ENCODINGS = 9,
-
-    // Dictionary selection for use problems.
-    DICTIONARY_FOUND_HAS_WRONG_DOMAIN = 10,
-    DICTIONARY_FOUND_HAS_WRONG_PORT_LIST = 11,
-    DICTIONARY_FOUND_HAS_WRONG_PATH = 12,
-    DICTIONARY_FOUND_HAS_WRONG_SCHEME = 13,
-    DICTIONARY_HASH_NOT_FOUND = 14,
-    DICTIONARY_HASH_MALFORMED = 15,
-
-    // Dictionary saving problems.
-    DICTIONARY_HAS_NO_HEADER = 20,
-    DICTIONARY_HEADER_LINE_MISSING_COLON = 21,
-    DICTIONARY_MISSING_DOMAIN_SPECIFIER = 22,
-    DICTIONARY_SPECIFIES_TOP_LEVEL_DOMAIN = 23,
-    DICTIONARY_DOMAIN_NOT_MATCHING_SOURCE_URL = 24,
-    DICTIONARY_PORT_NOT_MATCHING_SOURCE_URL = 25,
-    DICTIONARY_HAS_NO_TEXT = 26,
-    DICTIONARY_REFERER_URL_HAS_DOT_IN_PREFIX = 27,
-
-    // Dictionary loading problems.
-    DICTIONARY_LOAD_ATTEMPT_FROM_DIFFERENT_HOST = 30,
-    DICTIONARY_SELECTED_FOR_SSL = 31,
-    DICTIONARY_ALREADY_LOADED = 32,
-    DICTIONARY_SELECTED_FROM_NON_HTTP = 33,
-    DICTIONARY_IS_TOO_LARGE= 34,
-    DICTIONARY_COUNT_EXCEEDED = 35,
-    DICTIONARY_ALREADY_SCHEDULED_TO_DOWNLOAD = 36,
-    DICTIONARY_ALREADY_TRIED_TO_DOWNLOAD = 37,
-
-    // Failsafe hack.
-    ATTEMPT_TO_DECODE_NON_HTTP_DATA = 40,
-
-
-    // Content-Encoding problems detected, with no action taken.
-    MULTIENCODING_FOR_NON_SDCH_REQUEST = 50,
-    SDCH_CONTENT_ENCODE_FOR_NON_SDCH_REQUEST = 51,
-
-    // Dictionary manager issues.
-    DOMAIN_BLACKLIST_INCLUDES_TARGET = 61,
-
-    // Problematic decode recovery methods.
-    META_REFRESH_RECOVERY = 70,            // Dictionary not found.
-    // defunct =  71, // Almost the same as META_REFRESH_UNSUPPORTED.
-    // defunct = 72,  // Almost the same as CACHED_META_REFRESH_UNSUPPORTED.
-    // defunct = 73,  // PASSING_THROUGH_NON_SDCH plus
-                      // RESPONSE_TENTATIVE_SDCH in ../filter/sdch_filter.cc.
-    META_REFRESH_UNSUPPORTED = 74,         // Unrecoverable error.
-    CACHED_META_REFRESH_UNSUPPORTED = 75,  // As above, but pulled from cache.
-    PASSING_THROUGH_NON_SDCH = 76,  // Tagged sdch but missing dictionary-hash.
-    INCOMPLETE_SDCH_CONTENT = 77,   // Last window was not completely decoded.
-    PASS_THROUGH_404_CODE = 78,     // URL not found message passing through.
-
-    // This next report is very common, and not really an error scenario, but
-    // it exercises the error recovery logic.
-    PASS_THROUGH_OLD_CACHED = 79,   // Back button got pre-SDCH cached content.
-
-    // Common decoded recovery methods.
-    META_REFRESH_CACHED_RECOVERY = 80,  // Probably startup tab loading.
-    // defunct = 81, // Now tracked by ResponseCorruptionDetectionCause histo.
-
-    // Non SDCH problems, only accounted for to make stat counting complete
-    // (i.e., be able to be sure all dictionary advertisements are accounted
-    // for).
-
-    UNFLUSHED_CONTENT = 90,    // Possible error in filter chaining.
-    // defunct = 91,           // MISSING_TIME_STATS (Should never happen.)
-    CACHE_DECODED = 92,        // No timing stats recorded.
-    // defunct = 93,           // OVER_10_MINUTES (No timing stats recorded.)
-    UNINITIALIZED = 94,        // Filter never even got initialized.
-    PRIOR_TO_DICTIONARY = 95,  // We hadn't even parsed a dictionary selector.
-    DECODE_ERROR = 96,         // Something went wrong during decode.
-
-    // Problem during the latency test.
-    LATENCY_TEST_DISALLOWED = 100,  // SDCH now failing, but it worked before!
-
-    MAX_PROBLEM_CODE  // Used to bound histogram.
+    PROBLEM_CODE_OK = 0,
+
+#define SDCH_PROBLEM_CODE(label, value) label = value,
+#include "net/base/sdch_problem_code_list.h"
+#undef SDCH_PROBLEM_CODE
   };
 
   // Use the following static limits to block DOS attacks until we implement
@@ -206,19 +130,25 @@ class NET_EXPORT SdchManager
 
     const GURL& url() const { return url_; }
     const std::string& client_hash() const { return client_hash_; }
+    const std::string& domain() const { return domain_; }
+    const std::string& path() const { return path_; }
+    const base::Time& expiration() const { return expiration_; }
+    const std::set<int>& ports() const { return ports_; }
 
     // Security method to check if we can advertise this dictionary for use
     // if the |target_url| returns SDCH compressed data.
-    bool CanAdvertise(const GURL& target_url);
+    ProblemCodes CanAdvertise(const GURL& target_url) const;
 
     // Security methods to check if we can establish a new dictionary with the
     // given data, that arrived in response to get of dictionary_url.
-    static bool CanSet(const std::string& domain, const std::string& path,
-                       const std::set<int>& ports, const GURL& dictionary_url);
+    static ProblemCodes CanSet(const std::string& domain,
+                               const std::string& path,
+                               const std::set<int>& ports,
+                               const GURL& dictionary_url);
 
     // Security method to check if we can use a dictionary to decompress a
     // target that arrived with a reference to this dictionary.
-    bool CanUse(const GURL& referring_url);
+    ProblemCodes CanUse(const GURL& referring_url) const;
 
     // Compare paths to see if they "match" for dictionary use.
     static bool PathMatch(const std::string& path,
@@ -227,7 +157,6 @@ class NET_EXPORT SdchManager
     // Compare domains to see if the "match" for dictionary use.
     static bool DomainMatch(const GURL& url, const std::string& restriction);
 
-
     // The actual text of the dictionary.
     std::string text_;
 
@@ -302,18 +231,19 @@ class NET_EXPORT SdchManager
   // supported domain (i.e., not blacklisted, and either the specific supported
   // domain, or all domains were assumed supported). If it is blacklist, reduce
   // by 1 the number of times it will be reported as blacklisted.
-  bool IsInSupportedDomain(const GURL& url);
+  ProblemCodes IsInSupportedDomain(const GURL& url);
 
   // Schedule the URL fetching to load a dictionary. This will always return
   // before the dictionary is actually loaded and added.
   // After the implied task does completes, the dictionary will have been
   // cached in memory.
-  void FetchDictionary(const GURL& request_url, const GURL& dictionary_url);
+  ProblemCodes FetchDictionary(const GURL& request_url,
+                               const GURL& dictionary_url);
 
   // Security test function used before initiating a FetchDictionary.
-  // Return true if fetch is legal.
-  bool CanFetchDictionary(const GURL& referring_url,
-                          const GURL& dictionary_url) const;
+  // Return PROBLEM_CODE_OK if fetch is legal.
+  ProblemCodes CanFetchDictionary(const GURL& referring_url,
+                                  const GURL& dictionary_url) const;
 
   // Find the vcdiff dictionary (the body of the sdch dictionary that appears
   // after the meta-data headers like Domain:...) with the given |server_hash|
@@ -321,9 +251,12 @@ class NET_EXPORT SdchManager
   // be sure the returned |dictionary| can be used for decoding content supplied
   // in response to a request for |referring_url|.
   // Return null in |dictionary| if there is no matching legal dictionary.
-  void GetVcdiffDictionary(const std::string& server_hash,
-                           const GURL& referring_url,
-                           scoped_refptr<Dictionary>* dictionary);
+  // Returns PROBLEM_CODE_OK if dictionary is not found, SDCH(-over-https) is
+  // disabled, or if matching legal dictionary exists. Otherwise returns the
+  // corresponding problem code.
+  ProblemCodes GetVcdiffDictionary(const std::string& server_hash,
+                                   const GURL& referring_url,
+                                   scoped_refptr<Dictionary>* dictionary);
 
   // Get list of available (pre-cached) dictionaries that we have already loaded
   // into memory. The list is a comma separated list of (client) hashes per
@@ -344,6 +277,8 @@ class NET_EXPORT SdchManager
 
   void SetAllowLatencyExperiment(const GURL& url, bool enable);
 
+  base::Value* SdchInfoToValue() const;
+
   int GetFetchesCountForTesting() const {
     return fetches_count_for_testing_;
   }
@@ -355,14 +290,12 @@ class NET_EXPORT SdchManager
   // (data in the dictionary is not acceptable from the
   // dictionary_url; dictionary already added, etc.).
   virtual void AddSdchDictionary(const std::string& dictionary_text,
-                                 const GURL& dictionary_url) OVERRIDE;
+                                 const GURL& dictionary_url,
+                                 const BoundNetLog& net_log) OVERRIDE;
 
  private:
   struct BlacklistInfo {
-    BlacklistInfo()
-        : count(0),
-          exponential_count(0),
-          reason(MIN_PROBLEM_CODE) {}
+    BlacklistInfo() : count(0), exponential_count(0), reason(PROBLEM_CODE_OK) {}
 
     int count;                   // # of times to refuse SDCH advertisement.
     int exponential_count;       // Current exponential backoff ratchet.
@@ -385,6 +318,13 @@ class NET_EXPORT SdchManager
   // A simple implementation of a RFC 3548 "URL safe" base64 encoder.
   static void UrlSafeBase64Encode(const std::string& input,
                                   std::string* output);
+
+  // Helper function to write histogram and add event to net log.
+  static void LogDictionaryError(ProblemCodes error,
+                                 const GURL& url,
+                                 bool is_error,
+                                 const BoundNetLog& net_log);
+
   DictionaryMap dictionaries_;
 
   // An instance that can fetch a dictionary given a URL.