extensions/renderer/request_sender.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/renderer/request_sender.h"
   6
   7 #include "base/values.h"
   8 #include "content/public/renderer/render_frame.h"
   9 #include "extensions/common/extension_messages.h"
  10 #include "extensions/renderer/dispatcher.h"
  11 #include "extensions/renderer/script_context.h"
  12 #include "third_party/WebKit/public/web/WebDocument.h"
  13 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  14 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
  15 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
  16 #include "third_party/WebKit/public/web/WebUserGestureToken.h"
  17
  18 namespace extensions {
  19
  20 // Contains info relevant to a pending API request.
  21 struct PendingRequest {
  22  public:
  23   PendingRequest(const std::string& name,
  24                  RequestSender::Source* source,
  25                  blink::WebUserGestureToken token)
  26       : name(name), source(source), token(token) {}
  27
  28   std::string name;
  29   RequestSender::Source* source;
  30   blink::WebUserGestureToken token;
  31 };
  32
  33 RequestSender::ScopedTabID::ScopedTabID(RequestSender* request_sender,
  34                                         int tab_id)
  35     : request_sender_(request_sender),
  36       tab_id_(tab_id),
  37       previous_tab_id_(request_sender->source_tab_id_) {
  38   request_sender_->source_tab_id_ = tab_id;
  39 }
  40
  41 RequestSender::ScopedTabID::~ScopedTabID() {
  42   DCHECK_EQ(tab_id_, request_sender_->source_tab_id_);
  43   request_sender_->source_tab_id_ = previous_tab_id_;
  44 }
  45
  46 RequestSender::RequestSender(Dispatcher* dispatcher)
  47     : dispatcher_(dispatcher), source_tab_id_(-1) {}
  48
  49 RequestSender::~RequestSender() {}
  50
  51 void RequestSender::InsertRequest(int request_id,
  52                                   PendingRequest* pending_request) {
  53   DCHECK_EQ(0u, pending_requests_.count(request_id));
  54   pending_requests_[request_id].reset(pending_request);
  55 }
  56
  57 linked_ptr<PendingRequest> RequestSender::RemoveRequest(int request_id) {
  58   PendingRequestMap::iterator i = pending_requests_.find(request_id);
  59   if (i == pending_requests_.end())
  60     return linked_ptr<PendingRequest>();
  61   linked_ptr<PendingRequest> result = i->second;
  62   pending_requests_.erase(i);
  63   return result;
  64 }
  65
  66 int RequestSender::GetNextRequestId() const {
  67   static int next_request_id = 0;
  68   return next_request_id++;
  69 }
  70
  71 void RequestSender::StartRequest(Source* source,
  72                                  const std::string& name,
  73                                  int request_id,
  74                                  bool has_callback,
  75                                  bool for_io_thread,
  76                                  base::ListValue* value_args) {
  77   ScriptContext* context = source->GetContext();
  78   if (!context)
  79     return;
  80
  81   // Get the current RenderFrame so that we can send a routed IPC message from
  82   // the correct source.
  83   content::RenderFrame* render_frame = context->GetRenderFrame();
  84   if (!render_frame)
  85     return;
  86
  87   // TODO(koz): See if we can make this a CHECK.
  88   if (!context->HasAccessOrThrowError(name))
  89     return;
  90
  91   GURL source_url;
  92   if (blink::WebLocalFrame* webframe = context->web_frame())
  93     source_url = webframe->document().url();
  94
  95   InsertRequest(request_id, new PendingRequest(name, source,
  96       blink::WebUserGestureIndicator::currentUserGestureToken()));
  97
  98   ExtensionHostMsg_Request_Params params;
  99   params.name = name;
 100   params.arguments.Swap(value_args);
 101   params.extension_id = context->GetExtensionID();
 102   params.source_url = source_url;
 103   params.source_tab_id = source_tab_id_;
 104   params.request_id = request_id;
 105   params.has_callback = has_callback;
 106   params.user_gesture =
 107       blink::WebUserGestureIndicator::isProcessingUserGesture();
 108   if (for_io_thread) {
 109     render_frame->Send(new ExtensionHostMsg_RequestForIOThread(
 110         render_frame->GetRoutingID(), params));
 111   } else {
 112     render_frame->Send(
 113         new ExtensionHostMsg_Request(render_frame->GetRoutingID(), params));
 114   }
 115 }
 116
 117 void RequestSender::HandleResponse(int request_id,
 118                                    bool success,
 119                                    const base::ListValue& response,
 120                                    const std::string& error) {
 121   linked_ptr<PendingRequest> request = RemoveRequest(request_id);
 122
 123   if (!request.get()) {
 124     // This can happen if a context is destroyed while a request is in flight.
 125     return;
 126   }
 127
 128   blink::WebScopedUserGesture gesture(request->token);
 129   request->source->OnResponseReceived(
 130       request->name, request_id, success, response, error);
 131 }
 132
 133 void RequestSender::InvalidateSource(Source* source) {
 134   for (PendingRequestMap::iterator it = pending_requests_.begin();
 135        it != pending_requests_.end();) {
 136     if (it->second->source == source)
 137       pending_requests_.erase(it++);
 138     else
 139       ++it;
 140   }
 141 }
 142
 143 }  // namespace extensions