[Extensions] Update Error Console UI

chrome/browser/extensions/api/developer_private/extension_info_generator.cc

 // Copyright 2015 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/extensions/api/developer_private/extension_info_generator.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/developer_private/inspectable_views_finder.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
@@ skipping 53 matching lines @@
       type = developer::EXTENSION_TYPE_SHARED_MODULE;
       break;
     default:
       NOTREACHED();
   }
   return type;
 }
 
 // Populates the common fields of an extension error.
 template <typename ErrorType>
-void PopulateErrorBase(const ExtensionError& error,
-                       ErrorType* out) {
+void PopulateErrorBase(const ExtensionError& error, ErrorType* out) {
   CHECK(out);
   out->type = error.type() == ExtensionError::MANIFEST_ERROR ?
       developer::ERROR_TYPE_MANIFEST : developer::ERROR_TYPE_RUNTIME;
   out->extension_id = error.extension_id();
   out->from_incognito = error.from_incognito();
   out->source = base::UTF16ToUTF8(error.source());
   out->message = base::UTF16ToUTF8(error.message());
+  out->id = error.id();
 }
 
-// Given a ManifestError object, converts it into its developer_private
-// counterpart.
 linked_ptr<developer::ManifestError> ConstructManifestError(
     const ManifestError& error) {
   linked_ptr<developer::ManifestError> result(new developer::ManifestError());
   PopulateErrorBase(error, result.get());
   result->manifest_key = base::UTF16ToUTF8(error.manifest_key());
   if (!error.manifest_specific().empty()) {
     result->manifest_specific.reset(
         new std::string(base::UTF16ToUTF8(error.manifest_specific())));
   }
   return result;
 }
 
-// Given a RuntimeError object, converts it into its developer_private
-// counterpart.
 linked_ptr<developer::RuntimeError> ConstructRuntimeError(
     const RuntimeError& error) {
   linked_ptr<developer::RuntimeError> result(new developer::RuntimeError());
   PopulateErrorBase(error, result.get());
   switch (error.level()) {
     case logging::LOG_INFO:
       result->severity = developer::ERROR_LEVEL_LOG;
       break;
     case logging::LOG_WARNING:
       result->severity = developer::ERROR_LEVEL_WARN;
@@ skipping 245 matching lines @@
 
   info->version = extension.GetVersionForDisplay();
 
   if (state != developer::EXTENSION_STATE_TERMINATED) {
     info->views = InspectableViewsFinder(profile, nullptr).
                       GetViewsForExtension(extension, is_enabled);
   }
   return info.Pass();
 }
 
+scoped_ptr<api::developer_private::ExtensionInfo>
+ExtensionInfoGenerator::CreateExtensionInfo(const std::string& id) {
+  developer::ExtensionState state = developer::EXTENSION_STATE_ENABLED;
+  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
+  const Extension* extension = registry->enabled_extensions().GetByID(id);
+  if (!extension &&
+      (extension = registry->disabled_extensions().GetByID(id)) != nullptr) {

[Dan Beam, 2015/03/31 00:33:49]

:_(

[Devlin, 2015/03/31 16:17:50]

Why sad face?  I think it actually makes sense, as opposed to:
if (registry->disabled_extensions().GetByID(id))
  extension = registry->disabled_extensions().GetByID(id);
else if (registry->terminated_extensions().GetByID(id))
  extension = registry->terminated_extensions().GetByID(id);

not to mention, it saves a look-up.  Also might be worth noting this is a direct
copy over of the code from developer_private_api.cc; it's not new. :)

[Dan Beam, 2015/04/22 21:02:37]

eh, it's all awkward. whatevs.

+    state = developer::EXTENSION_STATE_DISABLED;
+  } else if (!extension &&
+             (extension =
+                  registry->terminated_extensions().GetByID(id)) != nullptr) {
+    state = developer::EXTENSION_STATE_TERMINATED;
+  }
+  scoped_ptr<api::developer_private::ExtensionInfo> info;
+  if (extension)
+    info = CreateExtensionInfo(*extension, state);
+  return info.Pass();
+}
+
 ExtensionInfoGenerator::ExtensionInfoList
 ExtensionInfoGenerator::CreateExtensionsInfo(bool include_disabled,
                                              bool include_terminated) {
   std::vector<linked_ptr<developer::ExtensionInfo>> list;
   auto add_to_list = [this, &list](const ExtensionSet& extensions,
                                       developer::ExtensionState state) {
     for (const scoped_refptr<const Extension>& extension : extensions) {
       if (ui_util::ShouldDisplayInExtensionSettings(extension.get(),
                                                     browser_context_)) {
         scoped_ptr<developer::ExtensionInfo> info =
@@ skipping 12 matching lines @@
   }
   if (include_terminated) {
     add_to_list(registry->terminated_extensions(),
                 developer::EXTENSION_STATE_TERMINATED);
   }
 
   return list;
 }
 
 }  // namespace extensions