[6] Moves CreateVersionFromString to plugin_utils and updates the callers.

chrome/browser/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/plugin_finder.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
+#include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/plugin_installer.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "grit/browser_resources.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 101 matching lines @@
   DCHECK(!installers_[identifier]);
   std::string url;
   bool success = plugin_dict->GetString("url", &url);
   std::string help_url;
   plugin_dict->GetString("help_url", &help_url);
   string16 name;
   success = plugin_dict->GetString("name", &name);
   DCHECK(success);
   bool display_url = false;
   plugin_dict->GetBoolean("displayurl", &display_url);
-
+  string16 group_name_matcher;
+  success = plugin_dict->GetString("group_name_matcher", &group_name_matcher);
+  DCHECK(success);
   PluginInstaller* installer = new PluginInstaller(identifier,
                                                    name,
                                                    display_url,
                                                    GURL(url),
-                                                   GURL(help_url));
+                                                   GURL(help_url),
+                                                   group_name_matcher);
   const ListValue* versions = NULL;
   if (plugin_dict->GetList("versions", &versions)) {
     for (ListValue::const_iterator it = versions->begin();
          it != versions->end(); ++it) {
       DictionaryValue* version_dict = NULL;
       if (!(*it)->GetAsDictionary(&version_dict)) {
         NOTREACHED();
         continue;
       }
       std::string version;
       success = version_dict->GetString("version", &version);
       DCHECK(success);
       std::string status_str;
       success = version_dict->GetString("status", &status_str);
       DCHECK(success);
       PluginInstaller::SecurityStatus status =
           PluginInstaller::SECURITY_STATUS_UP_TO_DATE;
       success = PluginInstaller::ParseSecurityStatus(status_str, &status);
       DCHECK(success);
       installer->AddVersion(Version(version), status);
     }
   }
 
   installers_[identifier] = installer;
   return installer;
 }
+
+// Note: this method triggers the lazy initialization for all PluginInstallers.

[Bernhard Bauer, 2012/08/21 19:14:52]

It doesn't matter very much, but what I meant originally was that it's not
obvious why we're calling a method called FindXYZ if we're ignoring the return
value, so I wanted to add the comment right above the method call.

+const std::map<std::string, PluginInstaller*>&
+PluginFinder::GetAllPluginInstallers() {
+  for (DictionaryValue::Iterator plugin_it(*plugin_list_);
+      plugin_it.HasNext(); plugin_it.Advance()) {
+    FindPluginWithIdentifier(plugin_it.key());
+  }
+
+  return installers_;
+}