Updated NetLog::ParametersCallback & all related calbacks returning value as scoped_ptr<base::Value…

net/filter/sdch_filter.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 "net/filter/sdch_filter.h"
 
 #include <ctype.h>
 #include <limits.h>
 
 #include <algorithm>
@@ skipping 72 matching lines @@
     case RESPONSE_ENCODING_LIE:
       cause_string = "ENCODING_LIE";
       break;
     case RESPONSE_MAX:
       cause_string = "<Error: max enum value>";
       break;
   }
   return cause_string;
 }
 
-base::Value* NetLogSdchResponseCorruptionDetectionCallback(
+scoped_ptr<base::Value> NetLogSdchResponseCorruptionDetectionCallback(
     ResponseCorruptionDetectionCause cause,
     bool cached,
     NetLogCaptureMode capture_mode) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("cause", ResponseCorruptionDetectionCauseToString(cause));
   dict->SetBoolean("cached", cached);
-  return dict;
+  return dict.Pass();
 }
 
 }  // namespace
 
 SdchFilter::SdchFilter(FilterType type, const FilterContext& filter_context)
     : Filter(type),
       filter_context_(filter_context),
       decoding_status_(DECODING_UNINITIALIZED),
       dictionary_hash_(),
       dictionary_hash_is_plausible_(false),
@@ skipping 222 matching lines @@
       // caches the histogram name based on the call site.
       if (filter_context_.IsCachedContent()) {
         UMA_HISTOGRAM_ENUMERATION(
             "Sdch3.ResponseCorruptionDetection.Cached", cause, RESPONSE_MAX);
       } else {
         UMA_HISTOGRAM_ENUMERATION(
             "Sdch3.ResponseCorruptionDetection.Uncached", cause, RESPONSE_MAX);
       }
       filter_context_.GetNetLog().AddEvent(
           NetLog::TYPE_SDCH_RESPONSE_CORRUPTION_DETECTION,
-          base::Bind(&NetLogSdchResponseCorruptionDetectionCallback, cause,
+          base::Bind(NetLogSdchResponseCorruptionDetectionCallback, cause,
                      filter_context_.IsCachedContent()));
 
       if (decoding_status_ == PASS_THROUGH) {
         dest_buffer_excess_ = dictionary_hash_;  // Send what we scanned.
       } else {
         // This is where we try to do the expensive meta-refresh.
         if (std::string::npos == mime_type_.find("text/html")) {
           // Since we can't do a meta-refresh (along with an exponential
           // backoff), we'll just make sure this NEVER happens again.
           SdchProblemCode problem = (filter_context_.IsCachedContent()
@@ skipping 202 matching lines @@
     dest_buffer_excess_.clear();
     dest_buffer_excess_index_ = 0;
   }
   return amount;
 }
 
 void SdchFilter::LogSdchProblem(SdchProblemCode problem) {
   SdchManager::SdchErrorRecovery(problem);
   filter_context_.GetNetLog().AddEvent(
       NetLog::TYPE_SDCH_DECODING_ERROR,
-      base::Bind(&NetLogSdchResourceProblemCallback, problem));
+      base::Bind(NetLogSdchResourceProblemCallback, problem));
 }
 
 }  // namespace net