Only inject mojo builtins to contexts with the mojoPrivate API feature.

extensions/renderer/module_system.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/renderer/module_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 93 matching lines @@
   v8::Local<v8::Object> obj = args.This();
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsString());
   v8::Maybe<bool> result =
       obj->DefineOwnProperty(args.GetIsolate()->GetCurrentContext(),
                              args[0]->ToString(), args[1], v8::ReadOnly);
   if (!result.FromMaybe(false))
     LOG(ERROR) << "Failed to set private property on the export.";
 }
 
+bool ContextNeedsMojoBindings(ScriptContext* context) {
+  // Mojo is only used from JS by some APIs so a context only needs the mojo
+  // bindings at least one is available.

[Devlin, 2016/10/13 14:44:14]

nit: "if at least one is available"? (missing "if")

[Sam McNally, 2016/10/13 22:24:50]

Done.

+  //
+  // Prefer to use Mojo from C++ if possible rather than adding to this list.
+  static const char* const kMojoUsingApis[] = {

[Devlin, 2016/10/13 14:44:14]

nitty nit: since variable names can't express the difference between "mojo-using
apis" (what this means) and "mojo using apis" (apis that are used by mojo),
let's rename this to something like "kApisUsingMojo" or "kApisRequiringMojo" (or
something along those lines).

[Sam McNally, 2016/10/13 22:24:50]

Done.

+      "mimeHandlerPrivate", "mojoPrivate",
+  };
+
+  for (const auto* api : kMojoUsingApis) {
+    if (context->GetAvailability(api).is_available())
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 std::string ModuleSystem::ExceptionHandler::CreateExceptionString(
     const v8::TryCatch& try_catch) {
   v8::Local<v8::Message> message(try_catch.Message());
   if (message.IsEmpty()) {
     return "try_catch has no message";
   }
 
   std::string resource_name = "<unknown resource>";
@@ skipping 38 matching lines @@
       base::Bind(&ModuleSystem::RequireAsync, base::Unretained(this)));
   RouteFunction("privates",
                 base::Bind(&ModuleSystem::Private, base::Unretained(this)));
 
   v8::Local<v8::Object> global(context->v8_context()->Global());
   v8::Isolate* isolate = context->isolate();
   SetPrivate(global, kModulesField, v8::Object::New(isolate));
   SetPrivate(global, kModuleSystem, v8::External::New(isolate, this));
 
   gin::ModuleRegistry::From(context->v8_context())->AddObserver(this);
-  // TODO(devlin): We really shouldn't be injecting mojo into every blessed
-  // extension context - it's wasteful. But it's better than injecting into
-  // every frame (previous behavior) so start with this while we investigate
-  // further. See crbug.com/636655.
   if (context_->GetRenderFrame() &&
-      context_->context_type() == Feature::BLESSED_EXTENSION_CONTEXT) {
+      context_->context_type() == Feature::BLESSED_EXTENSION_CONTEXT &&
+      ContextNeedsMojoBindings(context_)) {
     context_->GetRenderFrame()->EnsureMojoBuiltinsAreAvailable(
         context->isolate(), context->v8_context());
   }
 }
 
 ModuleSystem::~ModuleSystem() {
 }
 
 void ModuleSystem::Invalidate() {
   // Clear the module system properties from the global context. It's polite,
@@ skipping 574 matching lines @@
 
 void ModuleSystem::ClobberExistingNativeHandler(const std::string& name) {
   NativeHandlerMap::iterator existing_handler = native_handler_map_.find(name);
   if (existing_handler != native_handler_map_.end()) {
     clobbered_native_handlers_.push_back(std::move(existing_handler->second));
     native_handler_map_.erase(existing_handler);
   }
 }
 
 }  // namespace extensions