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

content/renderer/media/dtls_identity_service_unittest.cc

Index: content/renderer/media/dtls_identity_service_unittest.cc
diff --git a/content/renderer/media/dtls_identity_service_unittest.cc b/content/renderer/media/dtls_identity_service_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..557bd7542d4453e413c1aa428be78b50969cad76
--- /dev/null
+++ b/content/renderer/media/dtls_identity_service_unittest.cc
@@ -0,0 +1,67 @@
+// 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.
+
+#include "content/common/media/dtls_identity_messages.h"
+#include "content/public/test/mock_render_thread.h"
+#include "content/renderer/media/dtls_identity_service.h"
+#include "googleurl/src/gurl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/libjingle/source/talk/base/scoped_ptr.h"
+
+namespace content {
+namespace {
+
+class MockDTLSIdentityObserver : public DTLSIdentityObserver {
+ public:
+  virtual void OnCompleted(const std::string& certificate,
+                           const std::string& private_key) OVERRIDE {}
+};
+
+class DTLSIdentityServiceForTest : public DTLSIdentityService {
+ public:
+  DTLSIdentityServiceForTest(
+      const GURL& origin,
+      talk_base::scoped_ptr<DTLSIdentityObserver>& observer,
+      RenderThread* render_thread)
+      : DTLSIdentityService(origin, observer),
+        render_thread_(render_thread) {}
+
+ protected:
+  virtual RenderThread* GetRenderThread() OVERRIDE {
+    return render_thread_;
+  }
+
+ private:
+  RenderThread* render_thread_;
+};
+
+class DTLSIdentityServiceTest : public testing::Test {
+};
+
+TEST_F(DTLSIdentityServiceTest, RequestIdentity) {
+  const GURL origin("http://google.com");
+  const std::string identity_name = "a";
+  const std::string common_name = "b";
+
+  talk_base::scoped_ptr<DTLSIdentityObserver> identity_observer;
+  identity_observer.reset(new MockDTLSIdentityObserver());
+
+  MockRenderThread mock_render_thread;
+  DTLSIdentityServiceForTest service(
+      origin, identity_observer, &mock_render_thread);
+  service.Initialize();
+  service.RequestIdentity(identity_name, common_name);
+
+  const IPC::Message* msg = mock_render_thread.sink().GetFirstMessageMatching(
+      DTLSIdentityMsg_RequestIdentity::ID);
+  Tuple3<GURL, std::string, std::string> params;
+  DTLSIdentityMsg_RequestIdentity::Read(msg, &params);
+
+  EXPECT_EQ(origin, params.a);
+  EXPECT_EQ(identity_name, params.b);
+  EXPECT_EQ(common_name, params.c);

[Ami GONE FROM CHROMIUM, 2013/06/06 21:33:04]

The only thing this test tests is that when you request an identity an IPC is
crafted.  This doesn't seem like a worthwhile test.

(for example, the test code is significantly more complicated than the code it
is testing)

If you do decide to drop this test then you can simplify the non-test code
somewhat by dropping GetRenderThread().

+}
+
+}  // namespace
+}  // namespace content