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 128 matching lines @@
   local_state->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();
+  scoped_ptr<DictionaryValue> plugin_list(ComputePluginList());

[cevans, 2013/02/05 21:06:52]

I think I'd have found a comment here useful, along the lines of "here we're
loading the compiled-in plug-in metadata list. it may be replaced shortly by a
newer downloaded version via class blah"

[Bernhard Bauer, 2013/02/06 20:08:24]

Done.

+  if (plugin_list)
+    ReinitializePlugins(plugin_list.Pass());

[cevans, 2013/02/05 21:06:52]

In the common case (ENABLE_PLUGIN_INSTALLATION), ReinitializePlugins() has
already been called?

 }
 
 // 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();
+  scoped_ptr<DictionaryValue> plugin_list(LoadPluginList());
+  if (plugin_list)
+    ReinitializePlugins(plugin_list.Pass());
 #endif
   base::DictionaryValue* result = LoadPluginList();

[cevans, 2013/02/05 21:06:52]

I'm kind of confused -- we just called LoadPluginList() above (conditional to
some ifdef), so why are we doing the work of loading & parsing it again here?

[Bernhard Bauer, 2013/02/06 20:08:24]

Yes, that's what I meant by "merging it with upstream might have done some
stupid things to it" ;-) My brain wasn't really working when I uploaded it. I've
rewritten it quite a bit now though.

   if (result)
     return result;
   return new base::DictionaryValue();
 }
 
 // static
 DictionaryValue* PluginFinder::LoadPluginList() {
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
   base::StringPiece json_resource(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
@@ skipping 22 matching lines @@
 #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 17 matching lines @@
     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;
 }
 
 void PluginFinder::ReinitializePlugins(
-    const base::DictionaryValue& json_metadata) {
+    scoped_ptr<base::DictionaryValue> json_metadata) {
   base::AutoLock lock(mutex_);
+  int version = 0;  // If no version is defined, we default to 0.
+  const char kVersionKey[] = "x-version";
+  json_metadata->GetInteger(kVersionKey, &version);
+  if (version <= version_)
+    return;
+
+  json_metadata->Remove(kVersionKey, NULL);
+
+  version_ = version;
+
   STLDeleteValues(&identifier_plugin_);
   identifier_plugin_.clear();
 
-  plugin_list_.reset(json_metadata.DeepCopy());
-  InitInternal();
+  InitInternal(json_metadata.Pass());
 }
 #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();
@@ skipping 25 matching lines @@
 
   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_);
+void PluginFinder::InitInternal(scoped_ptr<base::DictionaryValue> plugin_list) {
+  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)) {
+    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
     }
   }
 }