Remove WebMediaPlayerDelegate null checks

content/renderer/media/webmediaplayer_ms.cc

 // Copyright 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/renderer/media/webmediaplayer_ms.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 125 matching lines @@
   base::ThreadChecker io_thread_checker_;
 
   base::WeakPtrFactory<FrameDeliverer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
 
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
-    base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
+    media::WebMediaPlayerDelegate* delegate,
     media::MediaLog* media_log,
     std::unique_ptr<MediaStreamRendererFactory> factory,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     scoped_refptr<base::TaskRunner> worker_task_runner,
     media::GpuVideoAcceleratorFactories* gpu_factories,
     const blink::WebString& sink_id,
     const blink::WebSecurityOrigin& security_origin)
     : frame_(frame),
@@ skipping 14 matching lines @@
       gpu_factories_(gpu_factories),
       initial_audio_output_device_id_(sink_id.utf8()),
       initial_security_origin_(security_origin.isNull()
                                    ? url::Origin()
                                    : url::Origin(security_origin)),
       volume_(1.0),
       volume_multiplier_(1.0),
       should_play_upon_shown_(false) {
   DVLOG(1) << __func__;
   DCHECK(client);
-  if (delegate_)
-    delegate_id_ = delegate_->AddObserver(this);
+  DCHECK(delegate_);
+  delegate_id_ = delegate_->AddObserver(this);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 }
 
 WebMediaPlayerMS::~WebMediaPlayerMS() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Destruct compositor resources in the proper order.
   get_client()->setWebLayer(nullptr);
   if (video_weblayer_)
     static_cast<cc::VideoLayer*>(video_weblayer_->layer())->StopUsingProvider();
 
   if (frame_deliverer_)
     io_task_runner_->DeleteSoon(FROM_HERE, frame_deliverer_.release());
 
   if (compositor_)
     compositor_->StopUsingProvider();
 
   if (video_frame_provider_)
     video_frame_provider_->Stop();
 
   if (audio_renderer_)
     audio_renderer_->Stop();
 
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
-  if (delegate_) {
-    delegate_->PlayerGone(delegate_id_);
-    delegate_->RemoveObserver(delegate_id_);
-  }
+  delegate_->PlayerGone(delegate_id_);
+  delegate_->RemoveObserver(delegate_id_);
 }
 
 void WebMediaPlayerMS::load(LoadType load_type,
                             const blink::WebMediaPlayerSource& source,
                             CORSMode /*cors_mode*/) {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(acolwell): Change this to DCHECK_EQ(load_type, LoadTypeMediaStream)
   // once Blink-side changes land.
@@ skipping 58 matching lines @@
     return;
 
   if (video_frame_provider_)
     video_frame_provider_->Resume();
 
   compositor_->StartRendering();
 
   if (audio_renderer_)
     audio_renderer_->Play();
 
-  if (delegate_) {
-    // TODO(perkj, magjed): We use OneShot focus type here so that it takes
-    // audio focus once it starts, and then will not respond to further audio
-    // focus changes. See http://crbug.com/596516 for more details.
-    delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(),
-                       media::MediaContentType::OneShot);
-    delegate_->SetIdle(delegate_id_, false);
-  }
+  // TODO(perkj, magjed): We use OneShot focus type here so that it takes
+  // audio focus once it starts, and then will not respond to further audio
+  // focus changes. See http://crbug.com/596516 for more details.
+  delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(),
+                     media::MediaContentType::OneShot);
+  delegate_->SetIdle(delegate_id_, false);
 
   paused_ = false;
 }
 
 void WebMediaPlayerMS::pause() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   should_play_upon_shown_ = false;
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PAUSE));
   if (paused_)
     return;
 
   if (video_frame_provider_)
     video_frame_provider_->Pause();
 
   compositor_->StopRendering();
   compositor_->ReplaceCurrentFrameWithACopy();
 
   if (audio_renderer_)
     audio_renderer_->Pause();
 
-  if (delegate_) {
-    delegate_->DidPause(delegate_id_);
-    delegate_->SetIdle(delegate_id_, true);
-  }
+  delegate_->DidPause(delegate_id_);
+  delegate_->SetIdle(delegate_id_, true);
 
   paused_ = true;
 }
 
 bool WebMediaPlayerMS::supportsSave() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
 }
 
 void WebMediaPlayerMS::seek(double seconds) {
@@ skipping 189 matching lines @@
 #endif  // defined(OS_ANDROID)
 }
 
 void WebMediaPlayerMS::OnFrameClosed() {
 #if defined(OS_ANDROID)
   if (!paused_) {
     pause();
     should_play_upon_shown_ = true;
   }
 
-  if (delegate_)
-    delegate_->PlayerGone(delegate_id_);
+  delegate_->PlayerGone(delegate_id_);
 
   if (frame_deliverer_) {
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
                               base::Unretained(frame_deliverer_.get()), true));
   }
 #endif  // defined(OS_ANDROID)
 }
 
 void WebMediaPlayerMS::OnFrameShown() {
@@ skipping 154 matching lines @@
 void WebMediaPlayerMS::ResetCanvasCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_.ResetCache();
 }
 
 void WebMediaPlayerMS::TriggerResize() {
   get_client()->sizeChanged();
 }
 
 }  // namespace content