Begin to enable extension APIs in Extension Service Worker.

extensions/renderer/request_sender.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/request_sender.h"
 
 #include "base/values.h"
 #include "content/public/renderer/render_frame.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/renderer/dispatcher.h"
@@ skipping 60 matching lines @@
 void RequestSender::StartRequest(Source* source,
                                  const std::string& name,
                                  int request_id,
                                  bool has_callback,
                                  bool for_io_thread,
                                  base::ListValue* value_args) {
   ScriptContext* context = source->GetContext();
   if (!context)
     return;
 
+  bool for_service_worker =
+      context->context_type() == Feature::SERVICE_WORKER_CONTEXT;
   // Get the current RenderFrame so that we can send a routed IPC message from
   // the correct source.
+  // Note that |render_frame| would be nullptr for Service Workers. Service
+  // Workers use control IPC instead.
   content::RenderFrame* render_frame = context->GetRenderFrame();
-  if (!render_frame)
+  if (!for_service_worker && !render_frame) {
+    // It is important to early exit here for non Service Worker contexts so
+    // that we do not create orphaned
+    // RenderFrame cannot be found PendingRequest below.

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

this comment needs to be reworded

[lazyboy, 2016/04/15 00:57:47]

Done.

     return;
+  }
 
   // TODO(koz): See if we can make this a CHECK.
   if (!context->HasAccessOrThrowError(name))
     return;
 
   GURL source_url;
   if (blink::WebLocalFrame* webframe = context->web_frame())
     source_url = webframe->document().url();
 
   InsertRequest(request_id, new PendingRequest(name, source,
       blink::WebUserGestureIndicator::currentUserGestureToken()));
 
   ExtensionHostMsg_Request_Params params;
   params.name = name;
   params.arguments.Swap(value_args);
   params.extension_id = context->GetExtensionID();
   params.source_url = source_url;
   params.source_tab_id = source_tab_id_;
   params.request_id = request_id;
   params.has_callback = has_callback;
   params.user_gesture =
       blink::WebUserGestureIndicator::isProcessingUserGesture();
+
+  // Set Service Worker specific params to default values.
+  params.worker_thread_id = -1;
+  params.embedded_worker_id = -1;
+
+  SendRequest(render_frame, for_io_thread, params);
+}
+
+void RequestSender::SendRequest(content::RenderFrame* render_frame,
+                                bool for_io_thread,
+                                ExtensionHostMsg_Request_Params& params) {
   if (for_io_thread) {
     render_frame->Send(new ExtensionHostMsg_RequestForIOThread(
         render_frame->GetRoutingID(), params));
   } else {
     render_frame->Send(
         new ExtensionHostMsg_Request(render_frame->GetRoutingID(), params));
   }
 }
 
 void RequestSender::HandleResponse(int request_id,
@@ skipping 16 matching lines @@
   for (PendingRequestMap::iterator it = pending_requests_.begin();
        it != pending_requests_.end();) {
     if (it->second->source == source)
       pending_requests_.erase(it++);
     else
       ++it;
   }
 }
 
 }  // namespace extensions