Handle malformed built-in PluginFinder data.

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/message_loop.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/plugins/plugin_metadata.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 101 matching lines @@
       DCHECK(success);
       plugin->AddVersion(Version(version), status);
     }
   }
 
   LoadMimeTypes(false, plugin_dict, plugin);
   LoadMimeTypes(true, plugin_dict, plugin);
   return plugin;
 }
 
+void RecordBuiltInPluginListError(int error_code) {
+  // JSONReader::JSON_PARSE_ERROR_COUNT is used for the case where the JSON
+  // value has the wrong type.
+  UMA_HISTOGRAM_ENUMERATION("PluginFinder.BuiltInPluginList.ErrorCode",
+                            error_code,
+                            base::JSONReader::JSON_PARSE_ERROR_COUNT + 1);

[Alexei Svitkine (slow), 2015/04/20 17:15:10]

You don't need +1 here.

Also, please update that enum definition with a comment mentioning it's used in
UMA and entries shouldn't be deleted or renumbered.

[Bernhard Bauer, 2015/04/21 16:34:11]

I'm (ab)using JSONReader::JSON_PARSE_ERROR_COUNT as a value (see comment above),
so the boundary value is the next one.
Done.

[Alexei Svitkine (slow), 2015/04/21 16:50:36]

I see. I don't think we should do this. Otherwise, if someone ever adds a new
entry to the enum, it will renumber things. Why not just add it to the enum?

+}
+
 }  // namespace
 
 // static
 void PluginFinder::RegisterPrefs(PrefRegistrySimple* registry) {
   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() : version_(-1) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 void PluginFinder::Init() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // Load the built-in plugin list first. If we have a newer version stored
   // locally or download one, we will replace this one with it.
   scoped_ptr<base::DictionaryValue> plugin_list(LoadBuiltInPluginList());
-  DCHECK(plugin_list);
+
+  // Gracefully handle the case where we couldn't parse the built-in plugin list
+  // for some reason (https://crbug.com/388560). TODO(bauerb): Change back to a
+  // DCHECK once we have gathered more data about the underlying problem.
+  if (!plugin_list)
+    return;
+
   ReinitializePlugins(plugin_list.get());
 }
 
 // static
 base::DictionaryValue* PluginFinder::LoadBuiltInPluginList() {
   base::StringPiece json_resource(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_PLUGIN_DB_JSON));
   std::string error_str;
+  int error_code = base::JSONReader::JSON_NO_ERROR;
   scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
-      json_resource,
-      base::JSON_PARSE_RFC,
-      NULL,
-      &error_str));
-  if (!value.get()) {
+      json_resource, base::JSON_PARSE_RFC, &error_code, &error_str));
+  if (!value) {
     DLOG(ERROR) << error_str;
-    return NULL;
+    RecordBuiltInPluginListError(error_code);
+    return nullptr;
   }
-  if (value->GetType() != base::Value::TYPE_DICTIONARY)
-    return NULL;
+
+  if (value->GetType() != base::Value::TYPE_DICTIONARY) {
+    // JSONReader::JSON_PARSE_ERROR_COUNT is used for the case where the JSON
+    // value has the wrong type.
+    RecordBuiltInPluginListError(base::JSONReader::JSON_PARSE_ERROR_COUNT);
+    return nullptr;
+  }
+
+  DCHECK_EQ(base::JSONReader::JSON_NO_ERROR, error_code);
+  RecordBuiltInPluginListError(error_code);
   return static_cast<base::DictionaryValue*>(value.release());
 }
 
 PluginFinder::~PluginFinder() {
 #if defined(ENABLE_PLUGIN_INSTALLATION)
   STLDeleteValues(&installers_);
 #endif
   STLDeleteValues(&identifier_plugin_);
 }
 
@@ skipping 109 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();
 }