src/content/browser/renderer_host/media/webrtc_identity_service_host_unittest.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 <deque>
   6
   7 #include "content/browser/child_process_security_policy_impl.h"
   8 #include "content/browser/media/webrtc_identity_store.h"
   9 #include "content/browser/renderer_host/media/webrtc_identity_service_host.h"
  10 #include "content/common/media/webrtc_identity_messages.h"
  11 #include "content/public/test/test_browser_thread_bundle.h"
  12 #include "ipc/ipc_message.h"
  13 #include "net/base/net_errors.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace content {
  17
  18 namespace {
  19
  20 const char FAKE_ORIGIN[] = "http://fake.com";
  21 const char FAKE_IDENTITY_NAME[] = "fake identity";
  22 const char FAKE_COMMON_NAME[] = "fake common name";
  23 const char FAKE_CERTIFICATE[] = "fake cert";
  24 const char FAKE_PRIVATE_KEY[] = "fake private key";
  25 const int FAKE_RENDERER_ID = 10;
  26
  27 class MockWebRTCIdentityStore : public WebRTCIdentityStore {
  28  public:
  29   MockWebRTCIdentityStore() : WebRTCIdentityStore(base::FilePath(), NULL) {}
  30
  31   virtual base::Closure RequestIdentity(
  32       const GURL& origin,
  33       const std::string& identity_name,
  34       const std::string& common_name,
  35       const CompletionCallback& callback) OVERRIDE {
  36     EXPECT_TRUE(callback_.is_null());
  37
  38     callback_ = callback;
  39     return base::Bind(&MockWebRTCIdentityStore::OnCancel,
  40                       base::Unretained(this));
  41   }
  42
  43   bool HasPendingRequest() const { return !callback_.is_null(); }
  44
  45   void RunCompletionCallback(int error,
  46                              const std::string& cert,
  47                              const std::string& key) {
  48     callback_.Run(error, cert, key);
  49     callback_.Reset();
  50   }
  51
  52  private:
  53   virtual ~MockWebRTCIdentityStore() {}
  54
  55   void OnCancel() { callback_.Reset(); }
  56
  57   CompletionCallback callback_;
  58 };
  59
  60 class WebRTCIdentityServiceHostForTest : public WebRTCIdentityServiceHost {
  61  public:
  62   explicit WebRTCIdentityServiceHostForTest(WebRTCIdentityStore* identity_store)
  63       : WebRTCIdentityServiceHost(FAKE_RENDERER_ID, identity_store) {
  64     ChildProcessSecurityPolicyImpl* policy =
  65         ChildProcessSecurityPolicyImpl::GetInstance();
  66     policy->Add(FAKE_RENDERER_ID);
  67   }
  68
  69   virtual bool Send(IPC::Message* message) OVERRIDE {
  70     messages_.push_back(*message);
  71     delete message;
  72     return true;
  73   }
  74
  75   virtual bool OnMessageReceived(const IPC::Message& message,
  76                                  bool* message_was_ok) OVERRIDE {
  77     return WebRTCIdentityServiceHost::OnMessageReceived(message,
  78                                                         message_was_ok);
  79   }
  80
  81   IPC::Message GetLastMessage() { return messages_.back(); }
  82
  83   int GetNumberOfMessages() { return messages_.size(); }
  84
  85   void ClearMessages() { messages_.clear(); }
  86
  87  private:
  88   virtual ~WebRTCIdentityServiceHostForTest() {
  89     ChildProcessSecurityPolicyImpl* policy =
  90         ChildProcessSecurityPolicyImpl::GetInstance();
  91     policy->Remove(FAKE_RENDERER_ID);
  92   }
  93
  94   std::deque<IPC::Message> messages_;
  95 };
  96
  97 class WebRTCIdentityServiceHostTest : public ::testing::Test {
  98  public:
  99   WebRTCIdentityServiceHostTest()
 100       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
 101         store_(new MockWebRTCIdentityStore()),
 102         host_(new WebRTCIdentityServiceHostForTest(store_.get())) {}
 103
 104   void SendRequestToHost() {
 105     bool ok;
 106     host_->OnMessageReceived(
 107         WebRTCIdentityMsg_RequestIdentity(
 108             GURL(FAKE_ORIGIN), FAKE_IDENTITY_NAME, FAKE_COMMON_NAME),
 109         &ok);
 110     ASSERT_TRUE(ok);
 111   }
 112
 113   void SendCancelRequestToHost() {
 114     bool ok;
 115     host_->OnMessageReceived(WebRTCIdentityMsg_CancelRequest(), &ok);
 116     ASSERT_TRUE(ok);
 117   }
 118
 119   void VerifyRequestFailedMessage(int error) {
 120     EXPECT_EQ(1, host_->GetNumberOfMessages());
 121     IPC::Message ipc = host_->GetLastMessage();
 122     EXPECT_EQ(ipc.type(), WebRTCIdentityHostMsg_RequestFailed::ID);
 123
 124     Tuple1<int> error_in_message;
 125     WebRTCIdentityHostMsg_RequestFailed::Read(&ipc, &error_in_message);
 126     EXPECT_EQ(error, error_in_message.a);
 127   }
 128
 129   void VerifyIdentityReadyMessage(const std::string& cert,
 130                                   const std::string& key) {
 131     EXPECT_EQ(1, host_->GetNumberOfMessages());
 132     IPC::Message ipc = host_->GetLastMessage();
 133     EXPECT_EQ(ipc.type(), WebRTCIdentityHostMsg_IdentityReady::ID);
 134
 135     Tuple2<std::string, std::string> identity_in_message;
 136     WebRTCIdentityHostMsg_IdentityReady::Read(&ipc, &identity_in_message);
 137     EXPECT_EQ(cert, identity_in_message.a);
 138     EXPECT_EQ(key, identity_in_message.b);
 139   }
 140
 141  protected:
 142   TestBrowserThreadBundle browser_thread_bundle_;
 143   scoped_refptr<MockWebRTCIdentityStore> store_;
 144   scoped_refptr<WebRTCIdentityServiceHostForTest> host_;
 145 };
 146
 147 }  // namespace
 148
 149 TEST_F(WebRTCIdentityServiceHostTest, TestSendAndCancelRequest) {
 150   SendRequestToHost();
 151   EXPECT_TRUE(store_->HasPendingRequest());
 152   SendCancelRequestToHost();
 153   EXPECT_FALSE(store_->HasPendingRequest());
 154 }
 155
 156 TEST_F(WebRTCIdentityServiceHostTest, TestOnlyOneRequestAllowed) {
 157   SendRequestToHost();
 158   EXPECT_TRUE(store_->HasPendingRequest());
 159   EXPECT_EQ(0, host_->GetNumberOfMessages());
 160   SendRequestToHost();
 161
 162   VerifyRequestFailedMessage(net::ERR_INSUFFICIENT_RESOURCES);
 163 }
 164
 165 TEST_F(WebRTCIdentityServiceHostTest, TestOnIdentityReady) {
 166   SendRequestToHost();
 167   store_->RunCompletionCallback(net::OK, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY);
 168   VerifyIdentityReadyMessage(FAKE_CERTIFICATE, FAKE_PRIVATE_KEY);
 169 }
 170
 171 TEST_F(WebRTCIdentityServiceHostTest, TestOnRequestFailed) {
 172   SendRequestToHost();
 173   store_->RunCompletionCallback(net::ERR_KEY_GENERATION_FAILED, "", "");
 174   VerifyRequestFailedMessage(net::ERR_KEY_GENERATION_FAILED);
 175 }
 176
 177 TEST_F(WebRTCIdentityServiceHostTest, TestOriginAccessDenied) {
 178   ChildProcessSecurityPolicyImpl* policy =
 179       ChildProcessSecurityPolicyImpl::GetInstance();
 180   policy->Remove(FAKE_RENDERER_ID);
 181
 182   SendRequestToHost();
 183   VerifyRequestFailedMessage(net::ERR_ACCESS_DENIED);
 184 }
 185
 186 }  // namespace content