Use url::Origin to represent security origins in MediaStream-related code.

content/renderer/media/media_stream_dispatcher_unittest.cc

 // Copyright (c) 2012 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/renderer/media/media_stream_dispatcher.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
 #include "media/base/audio_parameters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 
 namespace content {
 namespace {
 
 const int kRouteId = 0;
 const int kAudioSessionId = 3;
 const int kVideoSessionId = 5;
 const int kRequestId1 = 10;
 const int kRequestId2 = 20;
 const int kRequestId3 = 30;
@@ skipping 78 matching lines @@
 
   using MediaStreamDispatcher::GetNextIpcIdForTest;
   using RenderFrameObserver::OnMessageReceived;
 };
 
 class MediaStreamDispatcherTest : public ::testing::Test {
  public:
   MediaStreamDispatcherTest()
       : dispatcher_(new MediaStreamDispatcherUnderTest()),
         handler_(new MockMediaStreamDispatcherEventHandler),
-        security_origin_("http://test.com") {}
+        security_origin_(url::Origin(GURL("http://test.com"))) {}
 
   // Generates a request for a MediaStream and returns the request id that is
   // used in IPC. Use this returned id in CompleteGenerateStream to identify
   // the request.
   int GenerateStream(const StreamControls& controls, int request_id) {
     int next_ipc_id = dispatcher_->GetNextIpcIdForTest();
     dispatcher_->GenerateStream(request_id, handler_.get()->AsWeakPtr(),
                                 controls, security_origin_);
     return next_ipc_id;
   }
@@ skipping 38 matching lines @@
     if (controls.video.requested)
       EXPECT_EQ(dispatcher_->video_session_id(label, 0), kVideoSessionId);
 
     return label;
   }
 
  protected:
   base::MessageLoop message_loop_;
   std::unique_ptr<MediaStreamDispatcherUnderTest> dispatcher_;
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler_;
-  GURL security_origin_;
+  url::Origin security_origin_;
 };
 
 }  // namespace
 
 TEST_F(MediaStreamDispatcherTest, GenerateStreamAndStopDevices) {
   StreamControls controls(true, true);
 
   int ipc_request_id1 = GenerateStream(controls, kRequestId1);
   int ipc_request_id2 = GenerateStream(controls, kRequestId2);
   EXPECT_NE(ipc_request_id1, ipc_request_id2);
@@ skipping 23 matching lines @@
             StreamDeviceInfo::kNoId);
 }
 
 TEST_F(MediaStreamDispatcherTest, BasicVideoDevice) {
   std::unique_ptr<MediaStreamDispatcher> dispatcher(
       new MediaStreamDispatcher(NULL));
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler1(
       new MockMediaStreamDispatcherEventHandler);
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler2(
       new MockMediaStreamDispatcherEventHandler);
-  GURL security_origin;
+  url::Origin security_origin;
 
   int ipc_request_id1 = dispatcher->next_ipc_id_;
   dispatcher->EnumerateDevices(
       kRequestId1, handler1.get()->AsWeakPtr(),
       kVideoType,
       security_origin);
   int ipc_request_id2 = dispatcher->next_ipc_id_;
   EXPECT_NE(ipc_request_id1, ipc_request_id2);
   dispatcher->EnumerateDevices(
       kRequestId2, handler2.get()->AsWeakPtr(),
@@ skipping 68 matching lines @@
   EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(0));
   EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
 }
 
 TEST_F(MediaStreamDispatcherTest, TestFailure) {
   std::unique_ptr<MediaStreamDispatcher> dispatcher(
       new MediaStreamDispatcher(NULL));
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler(
       new MockMediaStreamDispatcherEventHandler);
   StreamControls components(true, true);
-  GURL security_origin;
+  url::Origin security_origin;
 
   // Test failure when creating a stream.
   int ipc_request_id1 = dispatcher->next_ipc_id_;
   dispatcher->GenerateStream(kRequestId1, handler.get()->AsWeakPtr(),
                              components, security_origin);
   dispatcher->OnMessageReceived(MediaStreamMsg_StreamGenerationFailed(
       kRouteId, ipc_request_id1, MEDIA_DEVICE_PERMISSION_DENIED));
 
   // Verify that the request have been completed.
   EXPECT_EQ(handler->request_id_, kRequestId1);
@@ skipping 30 matching lines @@
 
 TEST_F(MediaStreamDispatcherTest, CancelGenerateStream) {
   std::unique_ptr<MediaStreamDispatcher> dispatcher(
       new MediaStreamDispatcher(NULL));
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler(
       new MockMediaStreamDispatcherEventHandler);
   StreamControls components(true, true);
   int ipc_request_id1 = dispatcher->next_ipc_id_;
 
   dispatcher->GenerateStream(kRequestId1, handler.get()->AsWeakPtr(),
-                             components, GURL());
+                             components, url::Origin());
   dispatcher->GenerateStream(kRequestId2, handler.get()->AsWeakPtr(),
-                             components, GURL());
+                             components, url::Origin());
 
   EXPECT_EQ(2u, dispatcher->requests_.size());
   dispatcher->CancelGenerateStream(kRequestId2, handler.get()->AsWeakPtr());
   EXPECT_EQ(1u, dispatcher->requests_.size());
 
   // Complete the creation of stream1.
   StreamDeviceInfo audio_device_info;
   audio_device_info.device.name = "Microphone";
   audio_device_info.device.type = kAudioType;
   audio_device_info.session_id = kAudioSessionId;
@@ skipping 28 matching lines @@
   dispatcher_->OnMessageReceived(
       MediaStreamMsg_DeviceStopped(kRouteId, label, handler_->video_device_));
   // Verify that MediaStreamDispatcherEventHandler::OnDeviceStopped has been
   // called.
   EXPECT_EQ(label, handler_->device_stopped_label_);
   EXPECT_EQ(dispatcher_->video_session_id(label, 0),
             StreamDeviceInfo::kNoId);
 }
 
 }  // namespace content