Extract supported codecs from CDM component manifest.

chrome/browser/component_updater/component_updater_service.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_updater_service.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
+#include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_patcher.h"
@@ skipping 975 matching lines @@
   }
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
     ComponentUpdateService::Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }
+
+// 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* ReadComponentManifest(
+    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()) {
+    DLOG(ERROR) << "Failed to deserialize " << manifest.MaybeAsASCII() << ": "
+                << error;
+    return NULL;
+  }
+  if (!root->IsType(base::Value::TYPE_DICTIONARY)) {
+    return NULL;
+  }
+  return static_cast<base::DictionaryValue*>(root.release());

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

hmm, It'll be nice if we can return a scoped_ptr here. But we need to downcast
which isn't supported in scoped_ptr, so we'll have:

return
scoped_ptr<base::DictionaryValue>(static_cast<base::DictionaryValue*>(root.release()))

Or we can do something like:

base::DictionaryValue* dictionary;
if (!root->GetAsDictionary(dictionary))
  return NULL;

root.release();
return scoped_ptr<base::DictionaryValue>(dictionary);

But this is still not satisfactory... Thoughts?

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

I independently came up with that same long return statement (+ .Pass()). It's
not great, but from an API perspective, it's better to return the scoped_ptr.

+}