Generates the DTLS identity in browser process and returns it to render process.

content/browser/renderer_host/media/webrtc_identity_service_host.h

+// Copyright (c) 2013 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_WEBRTC_IDENTITY_SERVICE_HOST_H_
+#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_WEBRTC_IDENTITY_SERVICE_HOST_H_
+
+#include <map>
+#include <queue>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/time.h"
+#include "content/browser/media/webrtc_identity_store.h"
+#include "content/public/browser/browser_message_filter.h"
+
+class GURL;
+
+namespace content {
+
+// This class is the host for WebRTCIdentityService in the browser process.
+// It converts the IPC messages for requesting a WebRTC DTLS identity and
+// cancelling a pending request into calls of WebRTCIdentityStore. It also sends
+// the request result back to the renderer through IPC.
+class WebRTCIdentityServiceHost : public BrowserMessageFilter {
+ public:
+  explicit WebRTCIdentityServiceHost(WebRTCIdentityStore* identity_store);
+
+  // The max number of requests accepted per second. If more requests are made,
+  // the requests will be rejected and an IPC containing error
+  // ERR_INSUFFICIENT_RESOURCES will be sent back to the renderer.
+  static const int MAX_REQUESTS_PER_SECOND;

[Ryan Sleevi, 2013/06/27 00:14:55]

This is going to have issues compiling across different compilers (MSVC and GCC
don't play nice on this).

Can you not just allow one outstanding request per renderer? The inherent
PostTask involved with IPC will act as an effective rate limiter, by allowing a
fair scheduling, rather than allowing the renderer to enqueue an arbitrary
number of requests and serving them all.

+
+ protected:
+  virtual ~WebRTCIdentityServiceHost();
+
+  // content::BrowserMessageFilter override.
+  virtual bool OnMessageReceived(const IPC::Message& message,
+                                 bool* message_was_ok) OVERRIDE;
+
+  virtual void OnComplete(int request_id,
+                          int error,
+                          const std::string& certificate,
+                          const std::string& private_key);
+
+ private:
+  // Requests a DTLS identity from the DTLS identity store for the given
+  // |origin| and |identity_name|. If no such identity exists, a new one will be
+  // generated using the given |common_name|.
+  // |request_id| is a unique id chosen by the client and used to cancel a
+  // pending request.
+  void OnRequestIdentity(int request_id,
+                         const GURL& origin,
+                         const std::string& identity_name,
+                         const std::string& common_name);
+  // Cancels a pending request by its id. If there is no pending request having
+  // the same id, the call is ignored.
+  void OnCancelRequest(int request_id);
+
+  bool IsRequestAllowed();
+  void UpdateRequestTime();
+
+  typedef std::map<int, base::Closure> RequestCancelCallbackMap;
+  RequestCancelCallbackMap pending_request_cancel_callback_map_;
+  WebRTCIdentityStore* identity_store_;
+  std::queue<base::Time> recent_request_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebRTCIdentityServiceHost);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_WEBRTC_IDENTITY_SERVICE_HOST_H_