Media Remoting: Remove old interstitial implementation.

media/remoting/courier_renderer.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/courier_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 61 matching lines @@
       rpc_broker_(controller_->GetRpcBroker()),
       rpc_handle_(rpc_broker_->GetUniqueHandle()),
       remote_renderer_handle_(RpcBroker::kInvalidHandle),
       video_renderer_sink_(video_renderer_sink),
       clock_(new base::DefaultTickClock()),
       weak_factory_(this) {
   VLOG(2) << __func__;
   // Note: The constructor is running on the main thread, but will be destroyed
   // on the media thread. Therefore, all weak pointers must be dereferenced on
   // the media thread.
-  controller_->SetShowInterstitialCallback(
-      base::Bind(&CourierRenderer::RenderInterstitialAndShow,
-                 media_task_runner_, weak_factory_.GetWeakPtr()));
   const RpcBroker::ReceiveMessageCallback receive_callback =
       base::Bind(&CourierRenderer::OnMessageReceivedOnMainThread,
                  media_task_runner_, weak_factory_.GetWeakPtr());
   rpc_broker_->RegisterMessageReceiverCallback(rpc_handle_, receive_callback);
 }
 
 CourierRenderer::~CourierRenderer() {
   VLOG(2) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
-  // Post task on main thread to unset the interstial callback.
-  main_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&RendererController::SetShowInterstitialCallback, controller_,
-                 RendererController::ShowInterstitialCallback()));
-
   // Post task on main thread to unregister message receiver.
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RpcBroker::UnregisterMessageReceiverCallback,
                             rpc_broker_, rpc_handle_));
 
-  // If the "between sessions" interstitial is not the one currently showing,
-  // paint a blank black frame to clear remoting messaging.
-  if (interstitial_type_ != InterstitialType::BETWEEN_SESSIONS) {
-    scoped_refptr<VideoFrame> frame =
-        VideoFrame::CreateBlackFrame(gfx::Size(1280, 720));
-    PaintInterstitial(frame, InterstitialType::BETWEEN_SESSIONS);
+  if (video_renderer_sink_) {
+    video_renderer_sink_->PaintSingleFrame(
+        VideoFrame::CreateBlackFrame(gfx::Size(1280, 720)));
   }
 }
 
 void CourierRenderer::Initialize(MediaResource* media_resource,
                                  RendererClient* client,
                                  const PipelineStatusCB& init_cb) {
   VLOG(2) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(media_resource);
   DCHECK(client);
@@ skipping 568 matching lines @@
   // just run the callback without reporting error.
   if (!init_workflow_done_callback_.is_null()) {
     base::ResetAndReturn(&init_workflow_done_callback_).Run(PIPELINE_OK);
     return;
   }
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 }
 
-// static
-void CourierRenderer::RenderInterstitialAndShow(
-    scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-    base::WeakPtr<CourierRenderer> self,
-    const SkBitmap& background,
-    const gfx::Size& natural_size,
-    InterstitialType type) {
-  // Note: This is running on the main thread. |self| must only be dereferenced
-  // on the media thread.
-  scoped_refptr<VideoFrame> frame =
-      RenderInterstitialFrame(background, natural_size, type);
-  if (!frame) {
-    NOTREACHED();
-    return;
-  }
-  media_task_runner->PostTask(
-      FROM_HERE, base::Bind(&CourierRenderer::PaintInterstitial, self,
-                            std::move(frame), type));
-}
-
-void CourierRenderer::PaintInterstitial(scoped_refptr<VideoFrame> frame,
-                                        InterstitialType type) {
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
-  interstitial_type_ = type;
-  if (!video_renderer_sink_)
-    return;
-  video_renderer_sink_->PaintSingleFrame(frame);
-}
-
 void CourierRenderer::OnMediaTimeUpdated() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   if (!flush_cb_.is_null())
     return;  // Don't manage and check the queue when Flush() is on-going.
 
   base::TimeTicks current_time = clock_->NowTicks();
   if (current_time < ignore_updates_until_time_)
     return;  // Not stable yet.
 
   media_time_queue_.push_back(
@@ skipping 122 matching lines @@
         kBytesPerKilobit;
     DCHECK_GE(kilobits_per_second, 0);
     const base::CheckedNumeric<int> checked_kbps = kilobits_per_second;
     metrics_recorder_.OnVideoRateEstimate(
         checked_kbps.ValueOrDefault(std::numeric_limits<int>::max()));
   }
 }
 
 }  // namespace remoting
 }  // namespace media