Split ValueSerializer into separate Serializer and Deserializer classes.

chrome/browser/extensions/external_pref_loader.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 "chrome/browser/extensions/external_pref_loader.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 52 matching lines @@
   } while (true);
 
   return external_extension_paths;
 }
 
 // Extracts extension information from a json file serialized by |serializer|.
 // |path| is only used for informational purposes (outputted when an error
 // occurs). An empty dictionary is returned in case of failure (e.g. invalid
 // path or json content).
 // Caller takes ownership of the returned dictionary.
-base::DictionaryValue* ExtractExtensionPrefs(base::ValueSerializer* serializer,
-                                             const base::FilePath& path) {
+base::DictionaryValue* ExtractExtensionPrefs(
+    base::ValueDeserializer* deserializer,
+    const base::FilePath& path) {
   std::string error_msg;
-  base::Value* extensions = serializer->Deserialize(NULL, &error_msg);
+  base::Value* extensions = deserializer->Deserialize(NULL, &error_msg);
   if (!extensions) {
     LOG(WARNING) << "Unable to deserialize json data: " << error_msg
                  << " in file " << path.value() << ".";
     return new base::DictionaryValue;
   }
 
   base::DictionaryValue* ext_dictionary = NULL;
   if (extensions->GetAsDictionary(&ext_dictionary))
     return ext_dictionary;
 
@@ skipping 160 matching lines @@
       return;
     }
 #else
     // The only platform that uses this check is Mac OS.  If you add one,
     // you need to implement base::VerifyPathControlledByAdmin() for
     // that platform.
     NOTREACHED();
 #endif  // defined(OS_MACOSX)
   }
 
-  JSONFileValueSerializer serializer(json_file);
+  JSONFileValueDeserializer deserializer(json_file);
   scoped_ptr<base::DictionaryValue> ext_prefs(
-      ExtractExtensionPrefs(&serializer, json_file));
+      ExtractExtensionPrefs(&deserializer, json_file));
   if (ext_prefs)
     prefs->MergeDictionary(ext_prefs.get());
 }
 
 void ExternalPrefLoader::ReadStandaloneExtensionPrefFiles(
     base::DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   CHECK(NULL != prefs);
 
   // First list the potential .json candidates.
@@ skipping 15 matching lines @@
 #if defined(OS_WIN)
         base::UTF16ToASCII(
             extension_candidate_path.RemoveExtension().BaseName().value());
 #elif defined(OS_POSIX)
         extension_candidate_path.RemoveExtension().BaseName().value();
 #endif
 
     DVLOG(1) << "Reading json file: "
              << extension_candidate_path.LossyDisplayName();
 
-    JSONFileValueSerializer serializer(extension_candidate_path);
+    JSONFileValueDeserializer deserializer(extension_candidate_path);
     scoped_ptr<base::DictionaryValue> ext_prefs(
-        ExtractExtensionPrefs(&serializer, extension_candidate_path));
+        ExtractExtensionPrefs(&deserializer, extension_candidate_path));
     if (ext_prefs) {
       DVLOG(1) << "Adding extension with id: " << id;
       prefs->Set(id, ext_prefs.release());
     }
   }
 }
 
 ExternalTestingLoader::ExternalTestingLoader(
     const std::string& json_data,
     const base::FilePath& fake_base_path)
     : fake_base_path_(fake_base_path) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  JSONStringValueSerializer serializer(json_data);
+  JSONStringValueDeserializer deserializer(json_data);
   base::FilePath fake_json_path = fake_base_path.AppendASCII("fake.json");
-  testing_prefs_.reset(ExtractExtensionPrefs(&serializer, fake_json_path));
+  testing_prefs_.reset(ExtractExtensionPrefs(&deserializer, fake_json_path));
 }
 
 void ExternalTestingLoader::StartLoading() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prefs_.reset(testing_prefs_->DeepCopy());
   LoadFinished();
 }
 
 ExternalTestingLoader::~ExternalTestingLoader() {}
 
 const base::FilePath ExternalTestingLoader::GetBaseCrxFilePath() {
   return fake_base_path_;
 }
 
 }  // namespace extensions