Sdch view for net-internals

net/filter/sdch_filter.cc

Index: net/filter/sdch_filter.cc
diff --git a/net/filter/sdch_filter.cc b/net/filter/sdch_filter.cc
index 2ef5ad51d7c4dce79e350643d76a95cf02df12f8..88cead39ac25f53f6f33f0f15b41f07374322fac 100644
--- a/net/filter/sdch_filter.cc
+++ b/net/filter/sdch_filter.cc
@@ -12,6 +12,7 @@
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "net/base/sdch_manager.h"
+#include "net/base/sdch_net_log_params.h"
 #include "net/url_request/url_request_context.h"
 
 #include "sdch/open-vcdiff/src/google/vcdecoder.h"
@@ -50,7 +51,7 @@ SdchFilter::~SdchFilter() {
   if (vcdiff_streaming_decoder_.get()) {
     if (!vcdiff_streaming_decoder_->FinishDecoding()) {
       decoding_status_ = DECODING_ERROR;
-      SdchManager::SdchErrorRecovery(SdchManager::INCOMPLETE_SDCH_CONTENT);
+      LogSdchProblem(SdchManager::INCOMPLETE_SDCH_CONTENT);
       // Make it possible for the user to hit reload, and get non-sdch content.
       // Note this will "wear off" quickly enough, and is just meant to assure
       // in some rare case that the user is not stuck.
@@ -65,7 +66,7 @@ SdchFilter::~SdchFilter() {
 
   if (!dest_buffer_excess_.empty()) {
     // Filter chaining error, or premature teardown.
-    SdchManager::SdchErrorRecovery(SdchManager::UNFLUSHED_CONTENT);
+    LogSdchProblem(SdchManager::UNFLUSHED_CONTENT);
     UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBytesIn",
          static_cast<int>(filter_context_.GetByteReadCount()));
     UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBufferSize",
@@ -77,7 +78,7 @@ SdchFilter::~SdchFilter() {
   if (filter_context_.IsCachedContent()) {
     // Not a real error, but it is useful to have this tally.
     // TODO(jar): Remove this stat after SDCH stability is validated.
-    SdchManager::SdchErrorRecovery(SdchManager::CACHE_DECODED);
+    LogSdchProblem(SdchManager::CACHE_DECODED);
     return;  // We don't need timing stats, and we aready got ratios.
   }
 
@@ -101,15 +102,15 @@ SdchFilter::~SdchFilter() {
       return;
     }
     case DECODING_UNINITIALIZED: {
-      SdchManager::SdchErrorRecovery(SdchManager::UNINITIALIZED);
+      LogSdchProblem(SdchManager::UNINITIALIZED);
       return;
     }
     case WAITING_FOR_DICTIONARY_SELECTION: {
-      SdchManager::SdchErrorRecovery(SdchManager::PRIOR_TO_DICTIONARY);
+      LogSdchProblem(SdchManager::PRIOR_TO_DICTIONARY);
       return;
     }
     case DECODING_ERROR: {
-      SdchManager::SdchErrorRecovery(SdchManager::DECODE_ERROR);
+      LogSdchProblem(SdchManager::DECODE_ERROR);
       return;
     }
     case META_REFRESH_RECOVERY: {
@@ -175,7 +176,7 @@ Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
         // We could be more generous, but for now, only a "NOT FOUND" code will
         // cause a pass through.  All other bad codes will fall into a
         // meta-refresh.
-        SdchManager::SdchErrorRecovery(SdchManager::PASS_THROUGH_404_CODE);
+        LogSdchProblem(SdchManager::PASS_THROUGH_404_CODE);
         decoding_status_ = PASS_THROUGH;
       } else if (filter_context_.GetResponseCode() != 200) {
         // We need to meta-refresh, with SDCH disabled.
@@ -183,7 +184,7 @@ Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
                  && !dictionary_hash_is_plausible_) {
         // We must have hit the back button, and gotten content that was fetched
         // before we *really* advertised SDCH and a dictionary.
-        SdchManager::SdchErrorRecovery(SdchManager::PASS_THROUGH_OLD_CACHED);
+        LogSdchProblem(SdchManager::PASS_THROUGH_OLD_CACHED);
         decoding_status_ = PASS_THROUGH;
       } else if (possible_pass_through_) {
         // This is the potentially most graceful response. There really was no
@@ -193,7 +194,7 @@ Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
         // not to use sdch, even though there is a dictionary.  To be
         // conservative, we locally added the tentative sdch (fearing that a
         // proxy stripped it!) and we must now recant (pass through).
-        SdchManager::SdchErrorRecovery(SdchManager::DISCARD_TENTATIVE_SDCH);
+        LogSdchProblem(SdchManager::DISCARD_TENTATIVE_SDCH);
         // However.... just to be sure we don't get burned by proxies that
         // re-compress with gzip or other system, we can sniff to see if this
         // is compressed data etc.  For now, we do nothing, which gets us into
@@ -215,7 +216,7 @@ Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
         // though it is not!
         // Meta-refresh won't help, as we didn't advertise an SDCH dictionary!!
         // Worse yet, meta-refresh could lead to an infinite refresh loop.
-        SdchManager::SdchErrorRecovery(SdchManager::PASSING_THROUGH_NON_SDCH);
+        LogSdchProblem(SdchManager::PASSING_THROUGH_NON_SDCH);
         decoding_status_ = PASS_THROUGH;
         // ... but further back-off on advertising SDCH support.
         url_request_context_->sdch_manager()->BlacklistDomain(url_);
@@ -230,11 +231,9 @@ Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
           // backoff), we'll just make sure this NEVER happens again.
           url_request_context_->sdch_manager()->BlacklistDomainForever(url_);
           if (filter_context_.IsCachedContent())
-            SdchManager::SdchErrorRecovery(
-                SdchManager::CACHED_META_REFRESH_UNSUPPORTED);
+            LogSdchProblem(SdchManager::CACHED_META_REFRESH_UNSUPPORTED);
           else
-            SdchManager::SdchErrorRecovery(
-                SdchManager::META_REFRESH_UNSUPPORTED);
+            LogSdchProblem(SdchManager::META_REFRESH_UNSUPPORTED);
           return FILTER_ERROR;
         }
         // HTML content means we can issue a meta-refresh, and get the content
@@ -242,13 +241,12 @@ Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
         if (filter_context_.IsCachedContent()) {
           // Cached content is probably a startup tab, so we'll just get fresh
           // content and try again, without disabling sdch.
-          SdchManager::SdchErrorRecovery(
-              SdchManager::META_REFRESH_CACHED_RECOVERY);
+          LogSdchProblem(SdchManager::META_REFRESH_CACHED_RECOVERY);
         } else {
           // Since it wasn't in the cache, we definately need at least some
           // period of blacklisting to get the correct content.
           url_request_context_->sdch_manager()->BlacklistDomain(url_);
-          SdchManager::SdchErrorRecovery(SdchManager::META_REFRESH_RECOVERY);
+          LogSdchProblem(SdchManager::META_REFRESH_RECOVERY);
         }
         decoding_status_ = META_REFRESH_RECOVERY;
         // Issue a meta redirect with SDCH disabled.
@@ -302,7 +300,7 @@ Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
   if (!ret) {
     vcdiff_streaming_decoder_.reset(NULL);  // Don't call it again.
     decoding_status_ = DECODING_ERROR;
-    SdchManager::SdchErrorRecovery(SdchManager::DECODE_BODY_ERROR);
+    LogSdchProblem(SdchManager::DECODE_BODY_ERROR);
     return FILTER_ERROR;
   }
 
@@ -341,9 +339,12 @@ Filter::FilterStatus SdchFilter::InitializeDictionary() {
 
   if ('\0' == dictionary_hash_[kServerIdLength - 1]) {
     SdchManager* manager(url_request_context_->sdch_manager());
-    manager->GetVcdiffDictionary(
+    SdchManager::ProblemCodes rv = manager->GetVcdiffDictionary(
         std::string(dictionary_hash_, 0, kServerIdLength - 1),
-        url_, &dictionary_);
+        url_,
+        &dictionary_);
+    if (rv != SdchManager::PROBLEM_CODE_OK)
+      LogSdchProblem(rv);
   } else {
     dictionary_hash_is_plausible_ = false;
   }
@@ -359,9 +360,9 @@ Filter::FilterStatus SdchFilter::InitializeDictionary() {
       }
     }
     if (dictionary_hash_is_plausible_)
-      SdchManager::SdchErrorRecovery(SdchManager::DICTIONARY_HASH_NOT_FOUND);
+      LogSdchProblem(SdchManager::DICTIONARY_HASH_NOT_FOUND);
     else
-      SdchManager::SdchErrorRecovery(SdchManager::DICTIONARY_HASH_MALFORMED);
+      LogSdchProblem(SdchManager::DICTIONARY_HASH_MALFORMED);
     decoding_status_ = DECODING_ERROR;
     return FILTER_ERROR;
   }
@@ -391,4 +392,11 @@ int SdchFilter::OutputBufferExcess(char* const dest_buffer,
   return amount;
 }
 
+void SdchFilter::LogSdchProblem(SdchManager::ProblemCodes problem) {
+  SdchManager::SdchErrorRecovery(problem);
+  filter_context_.GetNetLog().AddEvent(
+      NetLog::TYPE_SDCH_RESOURCE_ERROR,
+      base::Bind(&NetLogSdchResourceProblemCallback, problem));
+}
+
 }  // namespace net