git cl format the first third of the net/base directory

net/base/sdch_manager.h

 // Copyright (c) 2011 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.
 
 // Provides global database of differential decompression dictionaries for the
 // SDCH filter (processes sdch enconded content).
 
 // Exactly one instance of SdchManager is built, and all references are made
 // into that collection.
 //
@@ skipping 53 matching lines @@
   // The Cancel() method is called to cancel all pending dictionary fetches.
   // This is used for implementation of ClearData() below.
   virtual void Cancel() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SdchFetcher);
 };
 
 //------------------------------------------------------------------------------
 
-class NET_EXPORT SdchManager
-    : public SdchFetcher::Delegate,
-      public NON_EXPORTED_BASE(base::NonThreadSafe) {
+class NET_EXPORT SdchManager : public SdchFetcher::Delegate,
+                               public NON_EXPORTED_BASE(base::NonThreadSafe) {
  public:
   // 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,
@@ skipping 26 matching lines @@
     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_IS_TOO_LARGE = 34,
     DICTIONARY_COUNT_EXCEEDED = 35,
     DICTIONARY_ALREADY_SCHEDULED_TO_DOWNLOAD = 36,
     DICTIONARY_ALREADY_TRIED_TO_DOWNLOAD = 37,
     DICTIONARY_FETCH_READ_FAILED = 38,
 
     // 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.
+    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.
+    // RESPONSE_TENTATIVE_SDCH in ../filter/sdch_filter.cc.

[Ryan Sleevi, 2014/10/11 02:04:47]

BUG in clang-format

[jkarlin, 2014/10/16 00:19:32]

You think?  It seems like it's asking a bit much to line up with the previous
line's comment within a comment.

[jkarlin, 2014/11/11 19:01:44]

Fixed by adding whitespace.

     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.
+    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.
+    UNFLUSHED_CONTENT = 90,  // Possible error in filter chaining.
     // defunct = 91,           // MISSING_TIME_STATS (Should never happen.)
-    CACHE_DECODED = 92,        // No timing stats recorded.
+    CACHE_DECODED = 92,  // No timing stats recorded.

[Ryan Sleevi, 2014/10/11 02:04:47]

bug in clang-format

[jkarlin, 2014/10/16 00:19:32]

ditto 

[jkarlin, 2014/11/11 19:01:44]

It would be nice if it lined up better but it seems not worse to wrap it  with a
"clang-format off/on".

     // 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.
   };
@@ skipping 30 matching lines @@
 
     const GURL& url() const { return url_; }
     const std::string& client_hash() const { return client_hash_; }
 
     // 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);
 
     // 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 bool 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);
 
     // Compare paths to see if they "match" for dictionary use.
     static bool PathMatch(const std::string& path,
                           const std::string& restriction);
 
     // 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_;
 
     // Part of the hash of text_ that the client uses to advertise the fact that
     // it has a specific dictionary pre-cached.
     std::string client_hash_;
 
     // The GURL that arrived with the text_ in a URL request to specify where
     // this dictionary may be used.
     const GURL url_;
@@ skipping 86 matching lines @@
 
   // 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
   // the SDCH spec.
   void GetAvailDictionaryList(const GURL& target_url, std::string* list);
 
   // Construct the pair of hashes for client and server to identify an SDCH
   // dictionary. This is only made public to facilitate unit testing, but is
   // otherwise private
   static void GenerateHash(const std::string& dictionary_text,
-                           std::string* client_hash, std::string* server_hash);
+                           std::string* client_hash,
+                           std::string* server_hash);
 
   // For Latency testing only, we need to know if we've succeeded in doing a
   // round trip before starting our comparative tests. If ever we encounter
   // problems with SDCH, we opt-out of the test unless/until we perform a
   // complete SDCH decoding.
   bool AllowLatencyExperiment(const GURL& url) const;
 
   void SetAllowLatencyExperiment(const GURL& url, bool enable);
 
-  int GetFetchesCountForTesting() const {
-    return fetches_count_for_testing_;
-  }
+  int GetFetchesCountForTesting() const { return fetches_count_for_testing_; }
 
   // Implementation of SdchFetcher::Delegate.
 
   // Add an SDCH dictionary to our list of availible
   // dictionaries. This addition will fail if addition is illegal
   // (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;
 
  private:
   struct BlacklistInfo {
     BlacklistInfo()
-        : count(0),
-          exponential_count(0),
-          reason(MIN_PROBLEM_CODE) {}
+        : count(0), exponential_count(0), reason(MIN_PROBLEM_CODE) {}
 
-    int count;                   // # of times to refuse SDCH advertisement.
-    int exponential_count;       // Current exponential backoff ratchet.
-    ProblemCodes reason;         // Why domain was blacklisted.
-
+    int count;              // # of times to refuse SDCH advertisement.
+    int exponential_count;  // Current exponential backoff ratchet.
+    ProblemCodes reason;    // Why domain was blacklisted.
   };
   typedef std::map<std::string, BlacklistInfo> DomainBlacklistInfo;
   typedef std::set<std::string> ExperimentSet;
 
   // A map of dictionaries info indexed by the hash that the server provides.
   typedef std::map<std::string, scoped_refptr<Dictionary> > DictionaryMap;
 
   // Support SDCH compression, by advertising in headers.
   static bool g_sdch_enabled_;
 
@@ skipping 17 matching lines @@
   ExperimentSet allow_latency_experiment_;
 
   int fetches_count_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchManager);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_SDCH_MANAGER_H_