Remove WebMediaPlayerDelegate null checks

content/renderer/media/android/webmediaplayer_android.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/android/webmediaplayer_android.h"
 
 #include <stddef.h>
 
 #include <limits>
 
@@ skipping 115 matching lines @@
 };
 
 }  // namespace
 
 namespace content {
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
-    base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
+    media::WebMediaPlayerDelegate* delegate,
     RendererMediaPlayerManager* player_manager,
     scoped_refptr<StreamTextureFactory> factory,
     int frame_id,
     bool enable_texture_copy,
     const media::WebMediaPlayerParams& params)
     : frame_(frame),
       client_(client),
       delegate_(delegate),
       delegate_id_(0),
       defer_load_cb_(params.defer_load_cb()),
@@ skipping 25 matching lines @@
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       frame_id_(frame_id),
       enable_texture_copy_(enable_texture_copy),
       suppress_deleting_texture_(false),
       playback_completed_(false),
       volume_(1.0),
       volume_multiplier_(1.0),
       weak_factory_(this) {
   DCHECK(player_manager_);
+  DCHECK(delegate_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  if (delegate_) {
-    delegate_id_ = delegate_->AddObserver(this);
-    delegate_->SetIdle(delegate_id_, true);
-  }
+  delegate_id_ = delegate_->AddObserver(this);
+  delegate_->SetIdle(delegate_id_, true);
 
   player_id_ = player_manager_->RegisterMediaPlayer(this);
 
   TryCreateStreamTextureProxyIfNeeded();
   interpolator_.SetUpperBound(base::TimeDelta());
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   SetVideoFrameProviderClient(NULL);
@@ skipping 11 matching lines @@
     gl->ShallowFlushCHROMIUM();
     texture_id_ = 0;
     texture_mailbox_ = gpu::Mailbox();
   }
 
   {
     base::AutoLock auto_lock(current_frame_lock_);
     current_frame_ = NULL;
   }
 
-  if (delegate_) {
-    delegate_->PlayerGone(delegate_id_);
-    delegate_->RemoveObserver(delegate_id_);
-  }
+  delegate_->PlayerGone(delegate_id_);
+  delegate_->RemoveObserver(delegate_id_);
 }
 
 void WebMediaPlayerAndroid::load(LoadType load_type,
                                  const blink::WebMediaPlayerSource& source,
                                  CORSMode cors_mode) {
   // Only URL or MSE blob URL is supported.
   DCHECK(source.isURL());
   blink::WebURL url = source.getAsURL();
   if (!defer_load_cb_.is_null()) {
     defer_load_cb_.Run(base::Bind(&WebMediaPlayerAndroid::DoLoad,
@@ skipping 56 matching lines @@
   return false;
 }
 
 void WebMediaPlayerAndroid::play() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (hasVideo() && player_manager_->render_frame()->IsHidden()) {
     bool can_video_play_in_background =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableMediaSuspend) ||
-        (IsBackgroundVideoCandidate() && delegate_ &&
+        (IsBackgroundVideoCandidate() &&
          delegate_->IsBackgroundVideoPlaybackUnlocked());
     if (!can_video_play_in_background) {
       is_play_pending_ = true;
       return;
     }
   }
   is_play_pending_ = false;
 
   TryCreateStreamTextureProxyIfNeeded();
   // There is no need to establish the surface texture peer for fullscreen
@@ skipping 512 matching lines @@
 
   // Lazily allocate compositing layer.
   if (!video_weblayer_) {
     video_weblayer_.reset(new cc_blink::WebLayerImpl(
         cc::VideoLayer::Create(this, media::VIDEO_ROTATION_0)));
     client_->setWebLayer(video_weblayer_.get());
 
     // If we're paused after we receive metadata for the first time, tell the
     // delegate we can now be safely suspended due to inactivity if a subsequent
     // play event does not occur.
-    if (paused() && delegate_) {
+    if (paused()) {
       delegate_->DidPause(delegate_id_);
       delegate_->SetIdle(delegate_id_, true);
     }
   }
 }
 
 void WebMediaPlayerAndroid::OnTimeUpdate(base::TimeDelta current_timestamp,
                                          base::TimeTicks current_time_ticks) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
@@ skipping 107 matching lines @@
   ready_state_ = state;
   client_->readyStateChanged();
 }
 
 void WebMediaPlayerAndroid::OnPlayerReleased() {
   needs_establish_peer_ = true;
 
   if (is_playing_)
     OnMediaPlayerPause();
 
-  if (delegate_)
-    delegate_->PlayerGone(delegate_id_);
+  delegate_->PlayerGone(delegate_id_);
 }
 
 void WebMediaPlayerAndroid::SuspendAndReleaseResources() {
   switch (network_state_) {
     // Pause the media player and inform WebKit if the player is in a good
     // shape.
     case WebMediaPlayer::NetworkStateIdle:
     case WebMediaPlayer::NetworkStateLoading:
     case WebMediaPlayer::NetworkStateLoaded:
       Pause(false);
       client_->playbackStateChanged();
-      if (delegate_)
-        delegate_->PlayerGone(delegate_id_);
+      delegate_->PlayerGone(delegate_id_);
       break;
     // If a WebMediaPlayer instance has entered into one of these states,
     // the internal network state in HTMLMediaElement could be set to empty.
     // And calling playbackStateChanged() could get this object deleted.
     case WebMediaPlayer::NetworkStateEmpty:
     case WebMediaPlayer::NetworkStateFormatError:
     case WebMediaPlayer::NetworkStateNetworkError:
     case WebMediaPlayer::NetworkStateDecodeError:
       break;
   }
@@ skipping 209 matching lines @@
   if (is_playing == is_playing_)
     return;
 
   is_playing_ = is_playing;
 
   if (is_playing)
     interpolator_.StartInterpolating();
   else
     interpolator_.StopInterpolating();
 
-  if (delegate_) {
-    if (is_playing) {
-      // We must specify either video or audio to the delegate, but neither may
-      // be known at this point -- there are no video only containers, so only
-      // send audio if we know for sure its audio.  The browser side player will
-      // fill in the correct value later for media sessions.
-      if (isRemote()) {
-        delegate_->PlayerGone(delegate_id_);
-      } else {
-        delegate_->DidPlay(delegate_id_, hasVideo(), !hasVideo(),
-                           media::DurationToMediaContentType(duration_));
-      }
-      delegate_->SetIdle(delegate_id_, false);
+  if (is_playing) {
+    // We must specify either video or audio to the delegate, but neither may
+    // be known at this point -- there are no video only containers, so only
+    // send audio if we know for sure its audio.  The browser side player will
+    // fill in the correct value later for media sessions.
+    if (isRemote()) {
+      delegate_->PlayerGone(delegate_id_);
     } else {
-      // Even if OnPlaybackComplete() has not been called yet, Blink may have
-      // already fired the ended event based on current time relative to
-      // duration -- so we need to check both possibilities here.
-      if (playback_completed_ || currentTime() >= duration()) {
-        delegate_->PlayerGone(delegate_id_);
-      } else {
-        delegate_->DidPause(delegate_id_);
-      }
-      delegate_->SetIdle(delegate_id_, true);
+      delegate_->DidPlay(delegate_id_, hasVideo(), !hasVideo(),
+                         media::DurationToMediaContentType(duration_));
     }
+    delegate_->SetIdle(delegate_id_, false);
+  } else {
+    // Even if OnPlaybackComplete() has not been called yet, Blink may have
+    // already fired the ended event based on current time relative to
+    // duration -- so we need to check both possibilities here.
+    if (playback_completed_ || currentTime() >= duration()) {
+      delegate_->PlayerGone(delegate_id_);
+    } else {
+      delegate_->DidPause(delegate_id_);
+    }
+    delegate_->SetIdle(delegate_id_, true);
   }
 }
 
 void WebMediaPlayerAndroid::OnFrameHidden() {
   // Pause audible video preserving its session.
   if (hasVideo() && IsBackgroundVideoCandidate() && !paused()) {
     Pause(false);
     is_play_pending_ = true;
     return;
   }
@@ skipping 100 matching lines @@
           switches::kDisableMediaSuspend)) {
     return false;
   }
 
   return base::FeatureList::IsEnabled(media::kResumeBackgroundVideo) &&
          hasAudio() && !isRemote() && delegate_ && delegate_->IsFrameHidden() &&
          !delegate_->IsFrameClosed();
 }
 
 }  // namespace content