Update webkit/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

webkit/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 "webkit/renderer/media/webmediaplayer_ms.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 50 matching lines @@
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 }
 
 WebMediaPlayerMS::~WebMediaPlayerMS() {
   DVLOG(1) << "WebMediaPlayerMS::dtor";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SetVideoFrameProviderClient(NULL);
   GetClient()->setWebLayer(NULL);
 
-  if (video_frame_provider_) {
+  if (video_frame_provider_.get()) {
     video_frame_provider_->Stop();
   }
 
-  if (audio_renderer_) {
+  if (audio_renderer_.get()) {
     if (audio_renderer_->IsLocalRenderer()) {
       audio_renderer_->Stop();
     } else if (!paused_) {
       // The |audio_renderer_| can be shared by multiple remote streams, and
       // it will be stopped when WebRtcAudioDeviceImpl goes away. So we simply
       // pause the |audio_renderer_| here to avoid re-creating the
       // |audio_renderer_|.
       audio_renderer_->Pause();
     }
   }
@@ skipping 17 matching lines @@
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 
   // Check if this url is media stream.
   video_frame_provider_ = media_stream_client_->GetVideoFrameProvider(
       url,
       base::Bind(&WebMediaPlayerMS::OnSourceError, AsWeakPtr()),
       base::Bind(&WebMediaPlayerMS::OnFrameAvailable, AsWeakPtr()));
 
   audio_renderer_ = media_stream_client_->GetAudioRenderer(url);
 
-  if (video_frame_provider_ || audio_renderer_) {
+  if (video_frame_provider_.get() || audio_renderer_.get()) {
     GetClient()->setOpaque(true);
-    if (audio_renderer_)
+    if (audio_renderer_.get())
       audio_renderer_->Start();
 
-    if (video_frame_provider_) {
+    if (video_frame_provider_.get()) {
       video_frame_provider_->Start();
     } else {
       // This is audio-only mode.
-      DCHECK(audio_renderer_);
+      DCHECK(audio_renderer_.get());
       SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
       SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
     }
   } else {
     SetNetworkState(WebMediaPlayer::NetworkStateNetworkError);
   }
 }
 
 void WebMediaPlayerMS::load(const WebKit::WebURL& url,
                             WebKit::WebMediaSource* media_source,
                             CORSMode cors_mode) {
   NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerMS::cancelLoad() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::play() {
   DVLOG(1) << "WebMediaPlayerMS::play";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (paused_) {
-    if (video_frame_provider_)
+    if (video_frame_provider_.get())
       video_frame_provider_->Play();
 
-    if (audio_renderer_)
+    if (audio_renderer_.get())
       audio_renderer_->Play();
 
     if (delegate_)
       delegate_->DidPlay(this);
   }
 
   paused_ = false;
 
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PLAY));
 }
 
 void WebMediaPlayerMS::pause() {
   DVLOG(1) << "WebMediaPlayerMS::pause";
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (video_frame_provider_)
+  if (video_frame_provider_.get())
     video_frame_provider_->Pause();
 
   if (!paused_) {
-    if (audio_renderer_)
+    if (audio_renderer_.get())
       audio_renderer_->Pause();
 
     if (delegate_)
       delegate_->DidPause(this);
   }
 
   paused_ = true;
 
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PAUSE));
 }
@@ skipping 11 matching lines @@
 void WebMediaPlayerMS::seek(double seconds) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setRate(double rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setVolume(double volume) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!audio_renderer_)
+  if (!audio_renderer_.get())
     return;
   DVLOG(1) << "WebMediaPlayerMS::setVolume(volume=" << volume << ")";
   audio_renderer_->SetVolume(volume);
 }
 
 void WebMediaPlayerMS::setVisible(bool visible) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setPreload(WebMediaPlayer::Preload preload) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool WebMediaPlayerMS::totalBytesKnown() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
 }
 
 bool WebMediaPlayerMS::hasVideo() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return (video_frame_provider_ != NULL);
+  return (video_frame_provider_.get() != NULL);
 }
 
 bool WebMediaPlayerMS::hasAudio() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return (audio_renderer_ != NULL);
+  return (audio_renderer_.get() != NULL);
 }
 
 WebKit::WebSize WebMediaPlayerMS::naturalSize() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   gfx::Size size;
-  if (current_frame_)
+  if (current_frame_.get())
     size = current_frame_->natural_size();
   DVLOG(3) << "WebMediaPlayerMS::naturalSize, " << size.ToString();
   return WebKit::WebSize(size);
 }
 
 bool WebMediaPlayerMS::paused() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return paused_;
 }
 
 bool WebMediaPlayerMS::seeking() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
 }
 
 double WebMediaPlayerMS::duration() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return std::numeric_limits<double>::infinity();
 }
 
 double WebMediaPlayerMS::currentTime() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (current_frame_) {
+  if (current_frame_.get()) {
     return current_frame_->GetTimestamp().InSecondsF();
-  } else if (audio_renderer_) {
+  } else if (audio_renderer_.get()) {
     return audio_renderer_->GetCurrentRenderTime().InSecondsF();
   }
   return 0.0;
 }
 
 int WebMediaPlayerMS::dataRate() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return 0;
 }
 
@@ skipping 34 matching lines @@
   // Don't need to do anything as we use the dimensions passed in via paint().
 }
 
 void WebMediaPlayerMS::paint(WebCanvas* canvas,
                              const WebRect& rect,
                              unsigned char alpha) {
   DVLOG(3) << "WebMediaPlayerMS::paint";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   gfx::RectF dest_rect(rect.x, rect.y, rect.width, rect.height);
-  video_renderer_.Paint(current_frame_, canvas, dest_rect, alpha);
+  video_renderer_.Paint(current_frame_.get(), canvas, dest_rect, alpha);
 
   {
     base::AutoLock auto_lock(current_frame_lock_);
-    if (current_frame_)
+    if (current_frame_.get())
       current_frame_used_ = true;
   }
 }
 
 bool WebMediaPlayerMS::hasSingleSecurityOrigin() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return true;
 }
 
 bool WebMediaPlayerMS::didPassCORSAccessCheck() const {
@@ skipping 40 matching lines @@
   // thread (when the main thread is blocked).
   if (video_frame_provider_client_)
     video_frame_provider_client_->StopUsingProvider();
   video_frame_provider_client_ = client;
 }
 
 scoped_refptr<media::VideoFrame> WebMediaPlayerMS::GetCurrentFrame() {
   DVLOG(3) << "WebMediaPlayerMS::GetCurrentFrame";
   base::AutoLock auto_lock(current_frame_lock_);
   DCHECK(!pending_repaint_);
-  if (!current_frame_)
+  if (!current_frame_.get())
     return NULL;
   pending_repaint_ = true;
   current_frame_used_ = true;
   return current_frame_;
 }
 
 void WebMediaPlayerMS::PutCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   DVLOG(3) << "WebMediaPlayerMS::PutCurrentFrame";
   DCHECK(pending_repaint_);
@@ skipping 10 matching lines @@
     {
       base::AutoLock auto_lock(current_frame_lock_);
       DCHECK(!current_frame_used_);
       current_frame_ =
           media::VideoFrame::CreateBlackFrame(frame->natural_size());
     }
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
     GetClient()->sizeChanged();
 
-    if (video_frame_provider_ && GetClient()->needsWebLayerForVideo()) {
+    if (video_frame_provider_.get() && GetClient()->needsWebLayerForVideo()) {
       video_weblayer_.reset(
           new webkit::WebLayerImpl(cc::VideoLayer::Create(this)));
       GetClient()->setWebLayer(video_weblayer_.get());
     }
   }
 
   // Do not update |current_frame_| when paused.
   if (paused_)
     return;
 
   if (!sequence_started_) {
     sequence_started_ = true;
     start_time_ = frame->GetTimestamp();
   }
-  bool size_changed = !current_frame_ ||
-      current_frame_->natural_size() != frame->natural_size();
+  bool size_changed = !current_frame_.get() ||
+                      current_frame_->natural_size() != frame->natural_size();
 
   {
     base::AutoLock auto_lock(current_frame_lock_);
-    if (!current_frame_used_ && current_frame_)
+    if (!current_frame_used_ && current_frame_.get())
       ++dropped_frame_count_;
     current_frame_ = frame;
     current_frame_->SetTimestamp(frame->GetTimestamp() - start_time_);
     current_frame_used_ = false;
   }
 
   if (size_changed)
     GetClient()->sizeChanged();
 
   GetClient()->repaint();
@@ skipping 26 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_media