Converted bare pointers to scoped_ptr in net/base

net/base/sdch_manager.cc

 // Copyright (c) 2012 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/base/sdch_manager.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 472 matching lines @@
 void SdchManager::UrlSafeBase64Encode(const std::string& input,
                                       std::string* output) {
   // Since this is only done during a dictionary load, and hashes are only 8
   // characters, we just do the simple fixup, rather than rewriting the encoder.
   base::Base64Encode(input, output);
   std::replace(output->begin(), output->end(), '+', '-');
   std::replace(output->begin(), output->end(), '/', '_');
 }
 
 base::Value* SdchManager::SdchInfoToValue() const {
-  base::DictionaryValue* value = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 
   value->SetBoolean("sdch_enabled", sdch_enabled());
   value->SetBoolean("secure_scheme_support", secure_scheme_supported());
 
-  base::ListValue* entry_list = new base::ListValue();
+  scoped_ptr<base::ListValue> entry_list(new base::ListValue());
   for (const auto& entry: dictionaries_) {
-    base::DictionaryValue* entry_dict = new base::DictionaryValue();
+    scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue());
     entry_dict->SetString("url", entry.second->data.url().spec());
     entry_dict->SetString("client_hash", entry.second->data.client_hash());
     entry_dict->SetString("domain", entry.second->data.domain());
     entry_dict->SetString("path", entry.second->data.path());
-    base::ListValue* port_list = new base::ListValue();
+    scoped_ptr<base::ListValue> port_list(new base::ListValue());
     for (std::set<int>::const_iterator port_it =
              entry.second->data.ports().begin();
          port_it != entry.second->data.ports().end(); ++port_it) {
       port_list->AppendInteger(*port_it);
     }
-    entry_dict->Set("ports", port_list);
+    entry_dict->Set("ports", port_list.Pass());
     entry_dict->SetString("server_hash", entry.first);
-    entry_list->Append(entry_dict);
+    entry_list->Append(entry_dict.Pass());
   }
-  value->Set("dictionaries", entry_list);
+  value->Set("dictionaries", entry_list.Pass());
 
-  entry_list = new base::ListValue();
+  entry_list.reset(new base::ListValue());
   for (DomainBlacklistInfo::const_iterator it = blacklisted_domains_.begin();
        it != blacklisted_domains_.end(); ++it) {
     if (it->second.count == 0)
       continue;
-    base::DictionaryValue* entry_dict = new base::DictionaryValue();
+    scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue());
     entry_dict->SetString("domain", it->first);
     if (it->second.count != INT_MAX)
       entry_dict->SetInteger("tries", it->second.count);
     entry_dict->SetInteger("reason", it->second.reason);
-    entry_list->Append(entry_dict);
+    entry_list->Append(entry_dict.Pass());
   }
-  value->Set("blacklisted", entry_list);
+  value->Set("blacklisted", entry_list.Pass());
 
-  return value;
+  return value.release();
 }
 
 }  // namespace net