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.
+}  // namespace.
+
 // 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) {
+scoped_ptr<base::DictionaryValue> ReadManifest(

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

I put this function back where it was, so you may want to diff this file against
base.

+    const base::FilePath& unpack_path) {
   base::FilePath manifest =
       unpack_path.Append(FILE_PATH_LITERAL("manifest.json"));
   if (!base::PathExists(manifest))
-    return NULL;
+    return scoped_ptr<base::DictionaryValue>();
   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());
+  if (!root.get()) {
+    DLOG(ERROR) << "Failed to deserialize " << manifest.MaybeAsASCII() << ": "

[cpu_(ooo_6.6-7.5), 2013/10/25 23:06:23]

please remove the DLOG

[ddorwin, 2013/10/25 23:27:27]

I removed it in the interest of time, but I'd like to put it back in a future
CL.
I find this particular DLOG to be very helpful since |error| contains the cause
of the parsing failure (e.g. trailing comma). I found this useful while manually
testing various scenarios.
WDYT?

+                << error;
+    return scoped_ptr<base::DictionaryValue>();
+  }
+  if (!root->IsType(base::Value::TYPE_DICTIONARY)) {
+    return scoped_ptr<base::DictionaryValue>();
+  }
+  return scoped_ptr<base::DictionaryValue>(

[cpu_(ooo_6.6-7.5), 2013/10/25 23:06:23]

With more pointer safety comes great verbosity. Nonplussed but I'll let it pass.

+      static_cast<base::DictionaryValue*>(root.release())).Pass();
 }
 
-}  // 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()) {
     error_ = kInvalidParams;
     return;
@@ skipping 79 matching lines @@
     return;
   }
   // Installation successful. The directory is not our concern now.
   unpack_path_.clear();
 }
 
 ComponentUnpacker::~ComponentUnpacker() {
   if (!unpack_path_.empty())
     base::DeleteFile(unpack_path_, true);
 }