Add a "key" entry to InstallWarnings, remove InstallWarning::Format

chrome/common/extensions/manifest_handlers/externally_connectable.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 "chrome/common/extensions/manifest_handlers/externally_connectable.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 100 matching lines @@
       URLPattern pattern(URLPattern::SCHEME_ALL);
       if (pattern.Parse(*it) != URLPattern::PARSE_SUCCESS) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kErrorInvalidMatchPattern, *it);
         return scoped_ptr<ExternallyConnectableInfo>();
       }
 
       // Wildcard hosts are not allowed.
       if (pattern.host().empty()) {
         // Warning not error for forwards compatibility.
-        install_warnings->push_back(
-            InstallWarning::Text(ErrorUtils::FormatErrorMessage(
-                errors::kErrorWildcardHostsNotAllowed, *it)));
+        install_warnings->push_back(InstallWarning(
+            ErrorUtils::FormatErrorMessage(
+                errors::kErrorWildcardHostsNotAllowed, *it),
+            keys::kExternallyConnectable,
+            *it));
         continue;
       }
 
       // Wildcards on subdomains of a TLD are not allowed.
       size_t registry_length = rcd::GetRegistryLength(
           pattern.host(),
           // This means that things that look like TLDs - the foobar in
           // http://google.foobar - count as TLDs.
           rcd::INCLUDE_UNKNOWN_REGISTRIES,
           // This means that effective TLDs like appspot.com count as TLDs;
           // codereview.appspot.com and evil.appspot.com are different.
           rcd::INCLUDE_PRIVATE_REGISTRIES);
 
       if (registry_length == std::string::npos) {
         // The URL parsing combined with host().empty() should have caught this.
         NOTREACHED() << *it;
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kErrorInvalidMatchPattern, *it);
         return scoped_ptr<ExternallyConnectableInfo>();
       }
 
       // Broad match patterns like "*.com", "*.co.uk", and even "*.appspot.com"
       // are not allowed. However just "appspot.com" is ok.
       if (registry_length == 0 && pattern.match_subdomains()) {
         // Warning not error for forwards compatibility.
-        install_warnings->push_back(InstallWarning::Text(
+        install_warnings->push_back(InstallWarning(
             ErrorUtils::FormatErrorMessage(
                 errors::kErrorTopLevelDomainsNotAllowed,
                 pattern.host().c_str(),
-                *it)));
+                *it),
+            keys::kExternallyConnectable,
+            *it));
         continue;
       }
 
       matches.AddPattern(pattern);
     }
   }
 
   std::vector<std::string> ids;
   bool all_ids = false;
 
   if (externally_connectable->ids) {
     for (std::vector<std::string>::iterator it =
              externally_connectable->ids->begin();
          it != externally_connectable->ids->end(); ++it) {
       if (*it == kAllIds) {
         all_ids = true;
       } else if (Extension::IdIsValid(*it)) {
         ids.push_back(*it);
       } else {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kErrorInvalidId, *it);
         return scoped_ptr<ExternallyConnectableInfo>();
       }
     }
   }
 
   if (!externally_connectable->matches &&
       !externally_connectable->ids) {
-    install_warnings->push_back(InstallWarning::Text(
-        errors::kErrorNothingSpecified));
+    install_warnings->push_back(InstallWarning(
+        errors::kErrorNothingSpecified,
+        keys::kExternallyConnectable));
   }
 
   return make_scoped_ptr(
       new ExternallyConnectableInfo(matches, ids, all_ids));
 }
 
 ExternallyConnectableInfo::~ExternallyConnectableInfo() {}
 
 ExternallyConnectableInfo::ExternallyConnectableInfo(
     const URLPatternSet& matches,
     const std::vector<std::string>& ids,
     bool all_ids)
     : matches(matches), ids(Sorted(ids)), all_ids(all_ids) {}
 
 bool ExternallyConnectableInfo::IdCanConnect(const std::string& id) {
   if (all_ids)
     return true;
   DCHECK(base::STLIsSorted(ids));
   return std::binary_search(ids.begin(), ids.end(), id);
 }
 
 }   // namespace extensions