content/renderer/media/webrtc_identity_service.cc

   1 // Copyright 2013 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 "content/renderer/media/webrtc_identity_service.h"
   6
   7 #include "base/location.h"
   8 #include "base/single_thread_task_runner.h"
   9 #include "base/thread_task_runner_handle.h"
  10 #include "content/common/media/webrtc_identity_messages.h"
  11 #include "content/public/renderer/render_thread.h"
  12 #include "net/base/net_errors.h"
  13
  14 namespace content {
  15
  16 WebRTCIdentityService::RequestInfo::RequestInfo(
  17     int request_id,
  18     const GURL& origin,
  19     const std::string& identity_name,
  20     const std::string& common_name,
  21     const SuccessCallback& success_callback,
  22     const FailureCallback& failure_callback)
  23     : request_id(request_id),
  24       origin(origin),
  25       identity_name(identity_name),
  26       common_name(common_name),
  27       success_callback(success_callback),
  28       failure_callback(failure_callback) {}
  29
  30 WebRTCIdentityService::RequestInfo::~RequestInfo() {}
  31
  32 WebRTCIdentityService::WebRTCIdentityService() : next_request_id_(1) {
  33   // RenderThread::Get() could be NULL in unit tests.
  34   if (RenderThread::Get())
  35     RenderThread::Get()->AddObserver(this);
  36 }
  37
  38 WebRTCIdentityService::~WebRTCIdentityService() {
  39   // RenderThread::Get() could be NULL in unit tests.
  40   if (RenderThread::Get()) {
  41     RenderThread::Get()->RemoveObserver(this);
  42
  43     if (!pending_requests_.empty()) {
  44       RenderThread::Get()->Send(new WebRTCIdentityMsg_CancelRequest());
  45     }
  46   }
  47 }
  48
  49 int WebRTCIdentityService::RequestIdentity(
  50     const GURL& origin,
  51     const std::string& identity_name,
  52     const std::string& common_name,
  53     const SuccessCallback& success_callback,
  54     const FailureCallback& failure_callback) {
  55   int request_id = next_request_id_++;
  56
  57   RequestInfo request_info(request_id,
  58                            origin,
  59                            identity_name,
  60                            common_name,
  61                            success_callback,
  62                            failure_callback);
  63
  64   pending_requests_.push_back(request_info);
  65   if (pending_requests_.size() == 1)
  66     SendRequest(request_info);
  67
  68   return request_id;
  69 }
  70
  71 void WebRTCIdentityService::CancelRequest(int request_id) {
  72   std::deque<RequestInfo>::iterator it;
  73   for (it = pending_requests_.begin(); it != pending_requests_.end(); ++it) {
  74     if (it->request_id != request_id)
  75       continue;
  76     if (it != pending_requests_.begin()) {
  77       pending_requests_.erase(it);
  78     } else {
  79       Send(new WebRTCIdentityMsg_CancelRequest());
  80       OnOutstandingRequestReturned();
  81     }
  82     break;
  83   }
  84 }
  85
  86 bool WebRTCIdentityService::Send(IPC::Message* message) {
  87   // Unit tests should override this method to avoid null-ptr-deref.
  88   return RenderThread::Get()->Send(message);
  89 }
  90
  91 bool WebRTCIdentityService::OnControlMessageReceived(
  92     const IPC::Message& message) {
  93   bool handled = true;
  94   IPC_BEGIN_MESSAGE_MAP(WebRTCIdentityService, message)
  95     IPC_MESSAGE_HANDLER(WebRTCIdentityHostMsg_IdentityReady, OnIdentityReady)
  96     IPC_MESSAGE_HANDLER(WebRTCIdentityHostMsg_RequestFailed, OnRequestFailed)
  97     IPC_MESSAGE_UNHANDLED(handled = false)
  98   IPC_END_MESSAGE_MAP()
  99
 100   return handled;
 101 }
 102
 103 void WebRTCIdentityService::OnIdentityReady(int request_id,
 104                                             const std::string& certificate,
 105                                             const std::string& private_key) {
 106   // The browser process may have sent the response before it receives the
 107   // message to cancel the request. So we need to check if the returned response
 108   // matches the request on the top of the queue.
 109   if (pending_requests_.empty() ||
 110       pending_requests_.front().request_id != request_id)
 111     return;
 112
 113   pending_requests_.front().success_callback.Run(certificate, private_key);
 114   OnOutstandingRequestReturned();
 115 }
 116
 117 void WebRTCIdentityService::OnRequestFailed(int request_id, int error) {
 118   // The browser process may have sent the response before it receives the
 119   // message to cancel the request. So we need to check if the returned response
 120   // matches the request on the top of the queue.
 121   if (pending_requests_.empty() ||
 122       pending_requests_.front().request_id != request_id)
 123     return;
 124
 125   pending_requests_.front().failure_callback.Run(error);
 126   OnOutstandingRequestReturned();
 127 }
 128
 129 void WebRTCIdentityService::SendRequest(const RequestInfo& request_info) {
 130   if (!Send(new WebRTCIdentityMsg_RequestIdentity(request_info.request_id,
 131                                                   request_info.origin,
 132                                                   request_info.identity_name,
 133                                                   request_info.common_name))) {
 134     base::ThreadTaskRunnerHandle::Get()->PostTask(
 135         FROM_HERE, base::Bind(&WebRTCIdentityService::OnRequestFailed,
 136                               base::Unretained(this), request_info.request_id,
 137                               net::ERR_UNEXPECTED));
 138   }
 139 }
 140
 141 void WebRTCIdentityService::OnOutstandingRequestReturned() {
 142   pending_requests_.pop_front();
 143
 144   if (!pending_requests_.empty())
 145     SendRequest(pending_requests_.front());
 146 }
 147
 148 }  // namespace content