Extensions: Send the tab id to platform apps.

chrome/renderer/extensions/request_sender.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/request_sender.h"
 
 #include "base/values.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 
 namespace extensions {
 
 // Contains info relevant to a pending API request.
 struct PendingRequest {
  public :
   PendingRequest(const std::string& name, RequestSender::Source* source)
       : name(name), source(source) {
   }
 
   std::string name;
   RequestSender::Source* source;
 };
 
-RequestSender::RequestSender(Dispatcher* dispatcher) : dispatcher_(dispatcher) {
+RequestSender::ScopedTabID::ScopedTabID(RequestSender* request_sender,
+                                        int tab_id)
+    : request_sender_(request_sender),
+      tab_id_(tab_id),
+      previous_tab_id_(request_sender->sender_tab_id_) {
+  request_sender_->sender_tab_id_ = tab_id;
+}
+
+RequestSender::ScopedTabID::~ScopedTabID() {
+  DCHECK_EQ(tab_id_, request_sender_->sender_tab_id_);
+  request_sender_->sender_tab_id_ = previous_tab_id_;
+}
+
+RequestSender::RequestSender(Dispatcher* dispatcher)
+    : dispatcher_(dispatcher),
+      sender_tab_id_(-1) {
 }
 
 RequestSender::~RequestSender() {
 }
 
 void RequestSender::InsertRequest(int request_id,
                                   PendingRequest* pending_request) {
   DCHECK_EQ(0u, pending_requests_.count(request_id));
   pending_requests_[request_id].reset(pending_request);
 }
@@ skipping 10 matching lines @@
 int RequestSender::GetNextRequestId() const {
   static int next_request_id = 0;
   return next_request_id++;
 }
 
 void RequestSender::StartRequest(Source* source,
                                  const std::string& name,
                                  int request_id,
                                  bool has_callback,
                                  bool for_io_thread,
+                                 int source_tab_id,
                                  base::ListValue* value_args) {
   ChromeV8Context* context = source->GetContext();
   if (!context)
     return;
 
   // Get the current RenderView so that we can send a routed IPC message from
   // the correct source.
   content::RenderView* renderview = context->GetRenderView();
   if (!renderview)
     return;
@@ skipping 13 matching lines @@
   if (blink::WebFrame* webframe = context->web_frame())
     source_url = webframe->document().url();
 
   InsertRequest(request_id, new PendingRequest(name, source));
 
   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;

[not at google - send to devlin, 2014/01/28 18:45:45]

I was imagining the source_tab_id would be read from this->source_tab_id_ rather
than needing to thread through messaging bindings, the custom bindings, and the
JS?

[Lei Zhang, 2014/01/28 22:52:27]

Ah, yes. That is much simpler. Done.

   params.request_id = request_id;
   params.has_callback = has_callback;
   params.user_gesture =
       blink::WebUserGestureIndicator::isProcessingUserGesture();
   if (for_io_thread) {
     renderview->Send(new ExtensionHostMsg_RequestForIOThread(
         renderview->GetRoutingID(), params));
   } else {
     renderview->Send(new ExtensionHostMsg_Request(
         renderview->GetRoutingID(), params));
@@ skipping 19 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