Extract supported codecs from CDM component manifest.

chrome/browser/component_updater/component_unpacker.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/component_updater/component_unpacker.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
-#include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
+#include "base/values.h"
 #include "chrome/browser/component_updater/component_patcher.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "crypto/secure_hash.h"
 #include "crypto/signature_verifier.h"
 #include "extensions/common/crx_file.h"
 #include "third_party/zlib/google/zip.h"
 
 using crypto::SecureHash;
 
@@ skipping 53 matching lines @@
   bool delta() const { return delta_; }
 
   const std::vector<uint8>& public_key() const { return public_key_; }
 
  private:
   bool valid_;
   bool delta_;
   std::vector<uint8> public_key_;
 };
 
-// Deserialize the CRX manifest. The top level must be a dictionary.
-// TODO(cpu): add a specific attribute check to a component json that the
-// extension unpacker will reject, so that a component cannot be installed
-// as an extension.
-base::DictionaryValue* ReadManifest(const base::FilePath& unpack_path) {
-  base::FilePath manifest =
-      unpack_path.Append(FILE_PATH_LITERAL("manifest.json"));
-  if (!base::PathExists(manifest))
-    return NULL;
-  JSONFileValueSerializer serializer(manifest);
-  std::string error;
-  scoped_ptr<base::Value> root(serializer.Deserialize(NULL, &error));
-  if (!root.get())
-    return NULL;
-  if (!root->IsType(base::Value::TYPE_DICTIONARY))
-    return NULL;
-  return static_cast<base::DictionaryValue*>(root.release());
-}
-
 }  // namespace.
 
 ComponentUnpacker::ComponentUnpacker(const std::vector<uint8>& pk_hash,
                                      const base::FilePath& path,
                                      const std::string& fingerprint,
                                      ComponentPatcher* patcher,
                                      ComponentInstaller* installer)
     : error_(kNone),
       extended_error_(0) {
   if (pk_hash.empty() || path.empty()) {
@@ skipping 55 matching lines @@
     if (error_ != kNone) {
       return;
     }
   } else {
     // Package is a normal update/install; unzip it into unpack_path_ directly.
     if (!zip::Unzip(path, unpack_path_)) {
       error_ = kUnzipFailed;
       return;
     }
   }
-  scoped_ptr<base::DictionaryValue> manifest(ReadManifest(unpack_path_));
+  scoped_ptr<base::DictionaryValue> manifest(
+      ReadComponentManifest(unpack_path_));
   if (!manifest.get()) {
     error_ = kBadManifest;
     return;
   }
   // Write the fingerprint to disk.
   if (static_cast<int>(fingerprint.size()) !=
       file_util::WriteFile(
           unpack_path_.Append(FILE_PATH_LITERAL("manifest.fingerprint")),
           fingerprint.c_str(),
           fingerprint.size())) {
     error_ = kFingerprintWriteFailed;
     return;
   }
   if (!installer->Install(*manifest, unpack_path_)) {

[xhwang, 2013/10/25 17:33:22]

Can we change the Install() to take scoped_ptr<base::DictionaryValue>, then we
can avoid some deepcopy downstream. Unfortunately this means that we need to
change ComponentInstaller and all it's implementors.

[ddorwin, 2013/10/25 19:03:40]

Added TODO in other file. I don't want to add more files to this CL.

     error_ = kInstallerError;
     return;
   }
   // Installation successful. The directory is not our concern now.
   unpack_path_.clear();
 }
 
 ComponentUnpacker::~ComponentUnpacker() {
   if (!unpack_path_.empty())
     base::DeleteFile(unpack_path_, true);
 }