Remove unneeded extension_messages_browsertest.cc + cleanup.

chrome/renderer/extensions/extension_dispatcher.cc

 // Copyright (c) 2012 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/renderer/extensions/extension_dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_piece.h"
@@ skipping 123 matching lines @@
         base::Bind(&LazyBackgroundPageNativeHandler::IncrementKeepaliveCount,
                    base::Unretained(this)));
     RouteFunction("DecrementKeepaliveCount",
         base::Bind(&LazyBackgroundPageNativeHandler::DecrementKeepaliveCount,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> IncrementKeepaliveCount(const v8::Arguments& args) {
     ChromeV8Context* context =
         extension_dispatcher()->v8_context_set().GetCurrent();
-    if (IsCurrentContextLazyBackgroundPage(context->extension_id())) {
+    if (IsCurrentContextLazyBackgroundPage(context->extension())) {
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_IncrementLazyKeepaliveCount(
-              context->extension_id()));
+              context->extension()->id()));
     }
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> DecrementKeepaliveCount(const v8::Arguments& args) {
     ChromeV8Context* context =
         extension_dispatcher()->v8_context_set().GetCurrent();
-    if (IsCurrentContextLazyBackgroundPage(context->extension_id())) {
+    if (IsCurrentContextLazyBackgroundPage(context->extension())) {
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_DecrementLazyKeepaliveCount(
-              context->extension_id()));
+              context->extension()->id()));
     }
     return v8::Undefined();
   }
 
  private:
-  bool IsCurrentContextLazyBackgroundPage(const std::string& extension_id) {
+  bool IsCurrentContextLazyBackgroundPage(const Extension* extension) {
     content::RenderView* render_view = GetCurrentRenderView();
     if (!render_view)
       return false;
 
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
-    const ::Extension* extension =
-        extension_dispatcher()->extensions()->GetByID(extension_id);
     return (extension && extension->has_lazy_background_page() &&
             helper->view_type() == chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   }
 };
 
 void InstallAppBindings(ModuleSystem* module_system,
                         v8::Handle<v8::Object> chrome,
                         v8::Handle<v8::Object> chrome_hidden) {
   module_system->SetLazyField(chrome, "app", "app", "chromeApp");
   module_system->SetLazyField(chrome, "appNotifications", "app",
@@ skipping 380 matching lines @@
 void ExtensionDispatcher::DidCreateScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int extension_group,
     int world_id) {
   // TODO(koz): If the caller didn't pass extension_group, use the last value.
   if (extension_group == -1)
     extension_group = g_hack_extension_group;
 
   std::string extension_id = GetExtensionID(frame, world_id);
 
   const Extension* extension = extensions_.GetByID(extension_id);
-  if (!extension && !extension_id.empty() && !IsTestExtensionId(extension_id)) {
+  if (!extension && !extension_id.empty()) {
     // There are conditions where despite a context being associated with an
     // extension, no extension actually gets found.  Ignore "invalid" because
     // CSP blocks extension page loading by switching the extension ID to
     // "invalid". This isn't interesting.
     if (extension_id != "invalid") {
       LOG(ERROR) << "Extension \"" << extension_id << "\" not found";
       RenderThread::Get()->RecordUserMetrics("ExtensionNotFound_ED");
     }
+
+    extension_id = "";
   }
 
   ExtensionURLInfo url_info(frame->document().securityOrigin(),
       UserScriptSlave::GetDataSourceURLForFrame(frame));
 
   Feature::Context context_type =
       ClassifyJavaScriptContext(extension_id, extension_group, url_info);
 
   ChromeV8Context* context =
-      new ChromeV8Context(v8_context, frame, extension_id, context_type);
+      new ChromeV8Context(v8_context, frame, extension, context_type);
   v8_context_set_.Add(context);
 
   scoped_ptr<ModuleSystem> module_system(new ModuleSystem(&source_map_));
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system.get());
 
   RegisterNativeHandlers(module_system.get(), context);
 
   module_system->RegisterNativeHandler("chrome_hidden",
       scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler()));
@@ skipping 29 matching lines @@
     case Feature::UNBLESSED_EXTENSION_CONTEXT:
     case Feature::CONTENT_SCRIPT_CONTEXT: {
       module_system->Require("miscellaneous_bindings");
       module_system->Require("schema_generated_bindings");
       module_system->Require("apitest");
 
       // TODO(kalman): move this code back out of the switch and execute it
       // regardless of |context_type|. ExtensionAPI knows how to return the
       // correct APIs, however, until it doesn't have a 2MB overhead we can't
       // load it in every process.
-      scoped_ptr<std::set<std::string> > apis =
-        ExtensionAPI::GetSharedInstance()->GetAPIsForContext(
-            context_type, extension, url_info.url());
-      for (std::set<std::string>::iterator i = apis->begin(); i != apis->end();
-          ++i) {
+      const std::set<std::string>& apis = context->GetAvailableExtensionAPIs();
+      for (std::set<std::string>::const_iterator i = apis.begin();
+           i != apis.end(); ++i) {
         InstallBindings(module_system.get(), v8_context, *i);
       }
 
       break;
     }
   }
 
-  // TODO(kalman): this is probably the most unfortunate thing I've ever had to
-  // write. We really need to factor things differently to delete the concept
-  // of a test extension ID.
-  if (IsTestExtensionId(extension_id)) {
-    module_system->Require("miscellaneous_bindings");
-    module_system->Require("schema_generated_bindings");
-    InstallBindings(module_system.get(), v8_context, "extension");
-  }
-
   // Inject custom JS into the platform app context to block certain features
   // of the document and window.
   if (extension && extension->is_platform_app())
     module_system->Require("platformApp");
 
   context->set_module_system(module_system.Pass());
 
   context->DispatchOnLoadEvent(
       is_extension_process_,
       ChromeRenderProcessObserver::is_incognito_process(),
       manifest_version);
 
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 std::string ExtensionDispatcher::GetExtensionID(WebFrame* frame, int world_id) {
-  if (!test_extension_id_.empty()) {
-    return test_extension_id_;
-  } else if (world_id != 0) {
+  if (world_id != 0) {
     // Isolated worlds (content script).
     return user_script_slave_->GetExtensionIdForIsolatedWorld(world_id);
   } else {
     // Extension pages (chrome-extension:// URLs).
     GURL frame_url = UserScriptSlave::GetDataSourceURLForFrame(frame);
     return extensions_.GetExtensionOrAppIDByURL(
         ExtensionURLInfo(frame->document().securityOrigin(), frame_url));
   }
 }
 
 void ExtensionDispatcher::WillReleaseScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int world_id) {
   ChromeV8Context* context = v8_context_set_.GetByV8Context(v8_context);
   if (!context)
     return;
 
   context->DispatchOnUnloadEvent();
 
   v8_context_set_.Remove(context);
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
-void ExtensionDispatcher::SetTestExtensionId(const std::string& id) {
-  CHECK(!id.empty());
-  test_extension_id_ = id;
-}
-
-bool ExtensionDispatcher::IsTestExtensionId(const std::string& id) {
-  return !test_extension_id_.empty() && id == test_extension_id_;
-}
-
 void ExtensionDispatcher::OnActivateExtension(
     const std::string& extension_id) {
   active_extension_ids_.insert(extension_id);
 
   // This is called when starting a new extension page, so start the idle
   // handler ticking.
   RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
 
   UpdateActiveExtensions();
 
@@ skipping 157 matching lines @@
 }
 
 bool ExtensionDispatcher::CheckCurrentContextAccessToExtensionAPI(
     const std::string& function_name) const {
   ChromeV8Context* context = v8_context_set().GetCurrent();
   if (!context) {
     DLOG(ERROR) << "Not in a v8::Context";
     return false;
   }
 
-  const ::Extension* extension = NULL;
-  if (!context->extension_id().empty()) {
-    extension = extensions()->GetByID(context->extension_id());
-  }
-
-  if (!extension || !extension->HasAPIPermission(function_name)) {
+  if (!context->extension() ||
+      !context->extension()->HasAPIPermission(function_name)) {
     static const char kMessage[] =
         "You do not have permission to use '%s'. Be sure to declare"
         " in your manifest what permissions you need.";
     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
     v8::ThrowException(
         v8::Exception::Error(v8::String::New(error_msg.c_str())));
     return false;
   }
 
-  if (!IsExtensionActive(extension->id()) &&
+  if (!IsExtensionActive(context->extension()->id()) &&
       ExtensionAPI::GetSharedInstance()->IsPrivileged(function_name)) {
     static const char kMessage[] =
         "%s can only be used in an extension process.";
     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
     v8::ThrowException(
         v8::Exception::Error(v8::String::New(error_msg.c_str())));
     return false;
   }
 
   return true;
 }