Media Remoting: Add remoting control logic for encrypted contents.

media/remoting/fake_remoting_controller.cc

 // Copyright 2016 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 "media/remoting/fake_remoting_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "media/remoting/remoting_controller.h"
+#include "media/remoting/remoting_source_impl.h"
 #include "media/remoting/rpc/proto_utils.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 FakeRemotingDataStreamSender::FakeRemotingDataStreamSender(
     mojom::RemotingDataStreamSenderRequest request,
     mojo::ScopedDataPipeConsumerHandle consumer_handle)
     : binding_(this, std::move(request)),
@@ skipping 77 matching lines @@
   ++send_frame_count_;
   received_frame_list.push_back(std::move(next_frame_data_));
   EXPECT_EQ(send_frame_count_, received_frame_list.size());
 }
 
 void FakeRemotingDataStreamSender::CancelInFlightData() {
   ++cancel_in_flight_count_;
 }
 
 FakeRemoter::FakeRemoter(mojom::RemotingSourcePtr source, bool start_will_fail)
-    : source_(std::move(source)), start_will_fail_(start_will_fail) {}
+    : source_(std::move(source)),
+      start_will_fail_(start_will_fail),
+      weak_factory_(this) {}
 
 FakeRemoter::~FakeRemoter() {}
 
 void FakeRemoter::Start() {
   if (start_will_fail_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(&FakeRemoter::StartFailed, base::Unretained(this)));
+        base::Bind(&FakeRemoter::StartFailed, weak_factory_.GetWeakPtr()));

[miu, 2016/11/05 04:05:15]

OOC, why were these changed to use WeakPtr? Can the test code not ensure all
tasks have run before tear-down like it did before?

[xjz, 2016/11/07 19:03:54]

WeakPtr is needed because when the RemotingSourceImpl is destroyed, FakeRemoter
will be destroyed as well due to strong binding. RemotingSourceImpl might be
immediately destroyed after sending stop(), in which case the FakeRemoter is
destroyed before calling FakeRemoter::StartFailed, and will crash.

   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&FakeRemoter::Started, base::Unretained(this)));
+        FROM_HERE,
+        base::Bind(&FakeRemoter::Started, weak_factory_.GetWeakPtr()));
   }
 }
 
 void FakeRemoter::StartDataStreams(
     mojo::ScopedDataPipeConsumerHandle audio_pipe,
     mojo::ScopedDataPipeConsumerHandle video_pipe,
     mojom::RemotingDataStreamSenderRequest audio_sender_request,
     mojom::RemotingDataStreamSenderRequest video_sender_request) {
   if (audio_pipe.is_valid()) {
     VLOG(2) << "Has audio";
     audio_stream_sender_.reset(new FakeRemotingDataStreamSender(
         std::move(audio_sender_request), std::move(audio_pipe)));
   }
 
   if (video_pipe.is_valid()) {
     VLOG(2) << "Has video";
     video_stream_sender_.reset(new FakeRemotingDataStreamSender(
         std::move(video_sender_request), std::move(video_pipe)));
   }
 }
 
 void FakeRemoter::Stop(mojom::RemotingStopReason reason) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&FakeRemoter::Stopped, base::Unretained(this), reason));
+      base::Bind(&FakeRemoter::Stopped, weak_factory_.GetWeakPtr(), reason));
 }
 
 void FakeRemoter::SendMessageToSink(const std::vector<uint8_t>& message) {}
 
 void FakeRemoter::Started() {
   source_->OnStarted();
 }
 
 void FakeRemoter::StartFailed() {
   source_->OnStartFailed(mojom::RemotingStartFailReason::ROUTE_TERMINATED);
 }
 
 void FakeRemoter::Stopped(mojom::RemotingStopReason reason) {
   source_->OnStopped(reason);
 }
 
 FakeRemoterFactory::FakeRemoterFactory(bool start_will_fail)
     : start_will_fail_(start_will_fail) {}
 
 FakeRemoterFactory::~FakeRemoterFactory() {}
 
 void FakeRemoterFactory::Create(mojom::RemotingSourcePtr source,
                                 mojom::RemoterRequest request) {
   mojo::MakeStrongBinding(
       base::MakeUnique<FakeRemoter>(std::move(source), start_will_fail_),
       std::move(request));
 }
 
-std::unique_ptr<RemotingController> CreateRemotingController(
+scoped_refptr<RemotingSourceImpl> CreateRemotingSourceImpl(
     bool start_will_fail) {
   mojom::RemotingSourcePtr remoting_source;
   mojom::RemotingSourceRequest remoting_source_request =
       mojo::GetProxy(&remoting_source);
   mojom::RemoterPtr remoter;
   std::unique_ptr<mojom::RemoterFactory> remoter_factory =
       base::MakeUnique<FakeRemoterFactory>(start_will_fail);
   remoter_factory->Create(std::move(remoting_source), mojo::GetProxy(&remoter));
-  std::unique_ptr<RemotingController> remoting_controller =
-      base::MakeUnique<RemotingController>(std::move(remoting_source_request),
-                                           std::move(remoter));
-  return remoting_controller;
+  return new RemotingSourceImpl(std::move(remoting_source_request),
+                                std::move(remoter));
 }
 
 }  // namespace media