Add versioning to PluginFinder metadata.

chrome/browser/plugins/plugin_finder.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/plugins/plugin_finder.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 129 matching lines @@
   registry->RegisterBooleanPref(prefs::kDisablePluginFinder, false);
 }
 
 // static
 PluginFinder* PluginFinder::GetInstance() {
   // PluginFinder::GetInstance() is the only method that's allowed to call
   // Singleton<PluginFinder>::get().
   return Singleton<PluginFinder>::get();
 }
 
-PluginFinder::PluginFinder() {
+PluginFinder::PluginFinder() : version_(-1) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 void PluginFinder::Init() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  plugin_list_.reset(ComputePluginList());
-  DCHECK(plugin_list_.get());
-
-  InitInternal();
+  // Load the built-in plug-in list first. If we have a newer version stored
+  // locally or download one, we will replace this one with it.
+  scoped_ptr<DictionaryValue> plugin_list(LoadBuiltInPluginList());

[Chris Evans, 2013/02/08 19:25:23]

Would it be possible to DCHECK(plugin_list.get()) here?
It'd give more immediate feedback if we typo the JSON file.

[Bernhard Bauer, 2013/02/11 09:58:19]

Done (although we have unit tests for that).

+  if (plugin_list)
+    ReinitializePlugins(plugin_list.get());
 }
 
 // static
-DictionaryValue* PluginFinder::ComputePluginList() {
-#if defined(ENABLE_PLUGIN_INSTALLATION)
-  const base::DictionaryValue* metadata =
-      g_browser_process->local_state()->GetDictionary(prefs::kPluginsMetadata);
-  if (!metadata->empty())
-    return metadata->DeepCopy();
-#endif
-  base::DictionaryValue* result = LoadPluginList();
-  if (result)
-    return result;
-  return new base::DictionaryValue();
-}
-
-// static
-DictionaryValue* PluginFinder::LoadPluginList() {
-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
+DictionaryValue* PluginFinder::LoadBuiltInPluginList() {
   base::StringPiece json_resource(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_PLUGIN_DB_JSON));
   std::string error_str;
   scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
       json_resource,
       base::JSON_PARSE_RFC,
       NULL,
       &error_str));
   if (!value.get()) {
     DLOG(ERROR) << error_str;
     return NULL;
   }
   if (value->GetType() != base::Value::TYPE_DICTIONARY)
     return NULL;
   return static_cast<base::DictionaryValue*>(value.release());
-#else
-  return new DictionaryValue();
-#endif
 }
 
 PluginFinder::~PluginFinder() {
 #if defined(ENABLE_PLUGIN_INSTALLATION)
   STLDeleteValues(&installers_);
 #endif
   STLDeleteValues(&identifier_plugin_);
 }
 
 #if defined(ENABLE_PLUGIN_INSTALLATION)
 bool PluginFinder::FindPlugin(
     const std::string& mime_type,
     const std::string& language,
     PluginInstaller** installer,
     scoped_ptr<PluginMetadata>* plugin_metadata) {
-  base::AutoLock lock(mutex_);
   if (g_browser_process->local_state()->GetBoolean(prefs::kDisablePluginFinder))
     return false;
 
+  base::AutoLock lock(mutex_);
   PluginMap::const_iterator metadata_it = identifier_plugin_.begin();
   for (; metadata_it != identifier_plugin_.end(); ++metadata_it) {
     if (language == metadata_it->second->language() &&
         metadata_it->second->HasMimeType(mime_type)) {
       *plugin_metadata = metadata_it->second->Clone();
 
       std::map<std::string, PluginInstaller*>::const_iterator installer_it =
           installers_.find(metadata_it->second->identifier());
       DCHECK(installer_it != installers_.end());
       *installer = installer_it->second;
@@ skipping 15 matching lines @@
 
   if (installer) {
     std::map<std::string, PluginInstaller*>::const_iterator installer_it =
         installers_.find(identifier);
     if (installer_it == installers_.end())
       return false;
     *installer = installer_it->second;
   }
   return true;
 }
+#endif
 
 void PluginFinder::ReinitializePlugins(
-    const base::DictionaryValue& json_metadata) {
+    const base::DictionaryValue* plugin_list) {
   base::AutoLock lock(mutex_);
+  int version = 0;  // If no version is defined, we default to 0.
+  const char kVersionKey[] = "x-version";
+  plugin_list->GetInteger(kVersionKey, &version);
+  if (version <= version_)
+    return;
+
+  version_ = version;
+
   STLDeleteValues(&identifier_plugin_);
   identifier_plugin_.clear();
 
-  plugin_list_.reset(json_metadata.DeepCopy());
-  InitInternal();
+  for (DictionaryValue::Iterator plugin_it(*plugin_list);
+      plugin_it.HasNext(); plugin_it.Advance()) {
+    const DictionaryValue* plugin = NULL;
+    const std::string& identifier = plugin_it.key();
+    if (plugin_list->GetDictionaryWithoutPathExpansion(identifier, &plugin)) {
+      DCHECK(!identifier_plugin_[identifier]);
+      identifier_plugin_[identifier] = CreatePluginMetadata(identifier, plugin);
+
+#if defined(ENABLE_PLUGIN_INSTALLATION)
+      if (installers_.find(identifier) == installers_.end())
+        installers_[identifier] = new PluginInstaller();
+#endif
+    }
+  }
 }
-#endif
 
 string16 PluginFinder::FindPluginNameWithIdentifier(
     const std::string& identifier) {
   base::AutoLock lock(mutex_);
   PluginMap::const_iterator it = identifier_plugin_.find(identifier);
   string16 name;
   if (it != identifier_plugin_.end())
     name = it->second->name();
 
   return name.empty() ? UTF8ToUTF16(identifier) : name;
@@ skipping 22 matching lines @@
     metadata->AddMatchingMimeType(plugin.mime_types[i].mime_type);
 
   DCHECK(metadata->MatchesPlugin(plugin));
   if (identifier_plugin_.find(identifier) != identifier_plugin_.end())
     identifier = GetLongIdentifier(plugin);
 
   DCHECK(identifier_plugin_.find(identifier) == identifier_plugin_.end());
   identifier_plugin_[identifier] = metadata;
   return metadata->Clone();
 }
-
-void PluginFinder::InitInternal() {
-  for (DictionaryValue::Iterator plugin_it(*plugin_list_);
-      plugin_it.HasNext(); plugin_it.Advance()) {
-    DictionaryValue* plugin = NULL;
-    const std::string& identifier = plugin_it.key();
-    if (plugin_list_->GetDictionaryWithoutPathExpansion(identifier, &plugin)) {
-      DCHECK(!identifier_plugin_[identifier]);
-      identifier_plugin_[identifier] = CreatePluginMetadata(identifier, plugin);
-
-#if defined(ENABLE_PLUGIN_INSTALLATION)
-      if (installers_.find(identifier) == installers_.end())
-        installers_[identifier] = new PluginInstaller();
-#endif
-    }
-  }
-}