Add ErrorConsole UI for Extension Install Warnings

extensions/browser/extension_error.cc

 // Copyright 2013 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 "extensions/browser/extension_error.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "extensions/common/constants.h"
 #include "url/gurl.h"
 
 using base::string16;
+using base::DictionaryValue;
 
 namespace extensions {
 
-namespace {
+////////////////////////////////////////////////////////////////////////////////
+// ExtensionError
 
-const char kLineNumberKey[] = "lineNumber";
-const char kColumnNumberKey[] = "columnNumber";
-const char kURLKey[] = "url";
-const char kFunctionNameKey[] = "functionName";
-const char kExecutionContextURLKey[] = "executionContextURL";
-const char kStackTraceKey[] = "stackTrace";
-
-// Try to retrieve an extension ID from a |url|. On success, returns true and
-// populates |extension_id| with the ID. On failure, returns false and leaves
-// extension_id untouched.
-bool GetExtensionIDFromGURL(const GURL& url, std::string* extension_id) {
-  if (url.SchemeIs(kExtensionScheme)) {
-    *extension_id = url.host();
-    return true;
-  }
-  return false;
-}
-
-}  // namespace
+// Static JSON keys.
+const char ExtensionError::kExtensionIdKey[] = "extensionId";
+const char ExtensionError::kFromIncognitoKey[] = "fromIncognito";
+const char ExtensionError::kLevelKey[] = "level";
+const char ExtensionError::kMessageKey[] = "message";
+const char ExtensionError::kSourceKey[] = "source";
+const char ExtensionError::kTypeKey[] = "type";
 
 ExtensionError::ExtensionError(Type type,
                                const std::string& extension_id,
                                bool from_incognito,
                                logging::LogSeverity level,
                                const string16& source,
                                const string16& message)
     : type_(type),
       extension_id_(extension_id),
       from_incognito_(from_incognito),
       level_(level),
       source_(source),
       message_(message),
       occurrences_(1u) {
 }
 
 ExtensionError::~ExtensionError() {
 }
 
+scoped_ptr<DictionaryValue> ExtensionError::ToValue() const {
+  // TODO(rdevlin.cronin): Use ValueBuilder when it's moved from
+  // chrome/common/extensions.
+  scoped_ptr<DictionaryValue> value(new DictionaryValue);
+  value->SetInteger(kTypeKey, static_cast<int>(type_));
+  value->SetString(kExtensionIdKey, extension_id_);
+  value->SetBoolean(kFromIncognitoKey, from_incognito_);
+  value->SetInteger(kLevelKey, static_cast<int>(level_));
+  value->SetString(kSourceKey, source_);
+  value->SetString(kMessageKey, message_);
+
+  return value.Pass();
+}
+
 std::string ExtensionError::PrintForTest() const {
   return std::string("Extension Error:") +
          "\n  OTR:     " + std::string(from_incognito_ ? "true" : "false") +
          "\n  Level:   " + base::IntToString(static_cast<int>(level_));
          "\n  Source:  " + base::UTF16ToUTF8(source_) +
          "\n  Message: " + base::UTF16ToUTF8(message_) +
          "\n  ID:      " + extension_id_;
 }
 
 bool ExtensionError::IsEqual(const ExtensionError* rhs) const {
   // We don't check |source_| or |level_| here, since they are constant for
   // manifest errors. Check them in RuntimeError::IsEqualImpl() instead.
   return type_ == rhs->type_ &&
          extension_id_ == rhs->extension_id_ &&
          message_ == rhs->message_ &&
          IsEqualImpl(rhs);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// ManifestError
+
+// Static JSON keys.
+const char ManifestError::kManifestKeyKey[] = "manifestKey";
+const char ManifestError::kManifestSpecificKey[] = "manifestSpecific";
+
 ManifestError::ManifestError(const std::string& extension_id,
                              const string16& message,
                              const string16& manifest_key,
                              const string16& manifest_specific)
     : ExtensionError(ExtensionError::MANIFEST_ERROR,
                      extension_id,
                      false,  // extensions can't be installed while incognito.
                      logging::LOG_WARNING,  // All manifest errors are warnings.
                      base::FilePath(kManifestFilename).AsUTF16Unsafe(),
                      message),
       manifest_key_(manifest_key),
       manifest_specific_(manifest_specific) {
 }
 
 ManifestError::~ManifestError() {
 }
 
+scoped_ptr<DictionaryValue> ManifestError::ToValue() const {
+  scoped_ptr<DictionaryValue> value = ExtensionError::ToValue();
+  if (!manifest_key_.empty())
+    value->SetString(kManifestKeyKey, manifest_key_);
+  if (!manifest_specific_.empty())
+    value->SetString(kManifestSpecificKey, manifest_specific_);
+  return value.Pass();
+}
+
 std::string ManifestError::PrintForTest() const {
   return ExtensionError::PrintForTest() +
          "\n  Type:    ManifestError";
 }
 
 bool ManifestError::IsEqualImpl(const ExtensionError* rhs) const {
   // If two manifest errors have the same extension id and message (which are
   // both checked in ExtensionError::IsEqual), then they are equal.
   return true;
 }
@@ skipping 63 matching lines @@
   // other systems), the source won't match up with the final entry in the stack
   // trace. (For instance, in a browser action error, the source is the page -
   // sometimes the background page - but the error is thrown from the script.)
   // Make the source match the stack trace, since that is more likely the cause
   // of the error.
   if (!stack_trace_.empty() && source_ != stack_trace_[0].source)
     source_ = stack_trace_[0].source;
 }
 
 }  // namespace extensions