Begin to enable extension APIs in Extension Service Worker.

extensions/common/features/simple_feature.cc

 // Copyright 2014 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/common/features/simple_feature.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 245 matching lines @@
     extension_types["hosted_app"] = Manifest::TYPE_HOSTED_APP;
     extension_types["platform_app"] = Manifest::TYPE_PLATFORM_APP;
     extension_types["shared_module"] = Manifest::TYPE_SHARED_MODULE;
 
     contexts["blessed_extension"] = Feature::BLESSED_EXTENSION_CONTEXT;
     contexts["unblessed_extension"] = Feature::UNBLESSED_EXTENSION_CONTEXT;
     contexts["content_script"] = Feature::CONTENT_SCRIPT_CONTEXT;
     contexts["web_page"] = Feature::WEB_PAGE_CONTEXT;
     contexts["blessed_web_page"] = Feature::BLESSED_WEB_PAGE_CONTEXT;
     contexts["webui"] = Feature::WEBUI_CONTEXT;
+    contexts["extension_service_worker"] = Feature::SERVICE_WORKER_CONTEXT;

[Devlin, 2016/04/13 19:46:31]

We should have this behind a flag (or just an internal bool we can flip for
testing/experimentation) until we get some of the TODOs ironed out.

[lazyboy, 2016/04/14 02:07:53]

I've added a bool in feature_util, used that to guard some key code: the message
filter and the ServiceWorkerData and worker request sender code. However this
very line is not guarded as I need to guard _api_features.json too.

Since we need to turn this on in tests, and we need to sync the bool in
renderer/ process, this also involves IPC :( Let me know if you have a better
suggestion.

[Devlin, 2016/04/14 22:34:52]

See suggestion in ipc messages.

 
     locations["component"] = SimpleFeature::COMPONENT_LOCATION;
     locations["external_component"] =
         SimpleFeature::EXTERNAL_COMPONENT_LOCATION;
     locations["policy"] = SimpleFeature::POLICY_LOCATION;
 
     platforms["chromeos"] = Feature::CHROMEOS_PLATFORM;
     platforms["linux"] = Feature::LINUX_PLATFORM;
     platforms["mac"] = Feature::MACOSX_PLATFORM;
     platforms["win"] = Feature::WIN_PLATFORM;
@@ skipping 156 matching lines @@
   if (extension) {
     Availability result = IsAvailableToManifest(extension->id(),
                                                 extension->GetType(),
                                                 extension->location(),
                                                 extension->manifest_version(),
                                                 platform);
     if (!result.is_available())
       return result;
   }
 
+  // TODO(lazyboy): This isn't quite right for Extension Service Worker
+  // extension API calls, since there's no guarantee that the extension is
+  // "active" in current renderer process when the API permission check is
+  // done.
   if (!contexts_.empty() && !ContainsValue(contexts_, context))
     return CreateAvailability(INVALID_CONTEXT, context);
 
   // TODO(kalman): Consider checking |matches_| regardless of context type.
   // Fewer surprises, and if the feature configuration wants to isolate
   // "matches" from say "blessed_extension" then they can use complex features.
   if ((context == WEB_PAGE_CONTEXT || context == WEBUI_CONTEXT) &&
       !matches_.MatchesURL(url)) {
     return CreateAvailability(INVALID_URL, url);
   }
@@ skipping 177 matching lines @@
 bool SimpleFeature::IsValidExtensionId(const std::string& extension_id) {
   // Belt-and-suspenders philosophy here. We should be pretty confident by this
   // point that we've validated the extension ID format, but in case something
   // slips through, we avoid a class of attack where creative ID manipulation
   // leads to hash collisions.
   // 128 bits / 4 = 32 mpdecimal characters
   return (extension_id.length() == 32);
 }
 
 }  // namespace extensions