Implement externally_connectable! Web pages can now communicate directly with

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"
 #include "chrome/common/extensions/api/manifest_types.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/permissions/api_permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_data.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/url_pattern.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 
@@ skipping 10 matching lines @@
     "as \"*\" are not allowed";
 const char kErrorWildcardHostsNotAllowed[] =
     "Wildcard domain patterns such as \"*\" are not allowed";
 }
 
 namespace keys = extension_manifest_keys;
 namespace errors = externally_connectable_errors;
 using api::manifest_types::ExternallyConnectable;
 
 namespace {
+
 const char kAllIds[] = "*";
+
+template <typename T>
+std::vector<T> Sorted(const std::vector<T>& in) {
+  std::vector<T> out = in;
+  std::sort(out.begin(), out.end());
+  return out;
 }
 
+} // namespace
+
 ExternallyConnectableHandler::ExternallyConnectableHandler() {}
 
 ExternallyConnectableHandler::~ExternallyConnectableHandler() {}
 
 bool ExternallyConnectableHandler::Parse(Extension* extension,
                                          string16* error) {
   const base::Value* externally_connectable = NULL;
   CHECK(extension->manifest()->Get(keys::kExternallyConnectable,
                                    &externally_connectable));
   scoped_ptr<ExternallyConnectableInfo> info =
@@ skipping 78 matching lines @@
             pattern.host().c_str(),
             *it);
         return scoped_ptr<ExternallyConnectableInfo>();
       }
 
       matches.AddPattern(pattern);
     }
   }
 
   std::vector<std::string> ids;
-  bool matches_all_ids = false;
+  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) {
-        matches_all_ids = true;
+        all_ids = true;
       } else if (Extension::IdIsValid(*it)) {
         ids.push_back(*it);
       } else {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kErrorInvalidId, *it);
         return scoped_ptr<ExternallyConnectableInfo>();
       }
     }
   }
 
   return make_scoped_ptr(
-      new ExternallyConnectableInfo(matches, ids, matches_all_ids));
+      new ExternallyConnectableInfo(matches, ids, all_ids));
 }
 
 ExternallyConnectableInfo::~ExternallyConnectableInfo() {}
 
 ExternallyConnectableInfo::ExternallyConnectableInfo(
     const URLPatternSet& matches,
     const std::vector<std::string>& ids,
-    bool matches_all_ids)
-    : matches(matches), ids(ids), matches_all_ids(matches_all_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