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

webkit/renderer/media/webmediaplayer_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 136 matching lines @@
       starting_(false),
       chunk_demuxer_(NULL),
       pending_repaint_(false),
       pending_size_change_(false),
       video_frame_provider_client_(NULL),
       text_track_index_(0) {
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   CHECK(media_thread_.Start());
-  pipeline_.reset(new media::Pipeline(
-      media_thread_.message_loop_proxy(), media_log_));
+  pipeline_.reset(new media::Pipeline(media_thread_.message_loop_proxy(),
+                                      media_log_.get()));
 
   // Let V8 know we started new thread if we did not do it yet.
   // Made separate task to avoid deletion of player currently being created.
   // Also, delaying GC until after player starts gets rid of starting lag --
   // collection happens in parallel with playing.
   //
   // TODO(enal): remove when we get rid of per-audio-stream thread.
   main_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
                  AsWeakPtr()));
 
   // Also we want to be notified of |main_loop_| destruction.
   base::MessageLoop::current()->AddDestructionObserver(this);
 
   if (WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
     decryptor_.reset(new ProxyDecryptor(
         client,
         frame,
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyAdded),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyError),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyMessage),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNeedKey)));
   }
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
-      params.audio_renderer_sink() ? params.audio_renderer_sink() :
-      new media::NullAudioSink(media_thread_.message_loop_proxy()));
+      params.audio_renderer_sink().get()
+          ? params.audio_renderer_sink()
+          : new media::NullAudioSink(media_thread_.message_loop_proxy()));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   SetVideoFrameProviderClient(NULL);
   GetClient()->setWebLayer(NULL);
 
   DCHECK(main_loop_->BelongsToCurrentThread());
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
@@ skipping 43 matching lines @@
 }  // anonymous namespace
 
 void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   LoadSetup(url);
 
   // Otherwise it's a regular request which requires resolving the URL first.
   GURL gurl(url);
   data_source_.reset(new BufferedDataSource(
-      main_loop_, frame_, media_log_, base::Bind(
-          &WebMediaPlayerImpl::NotifyDownloading, AsWeakPtr())));
+      main_loop_,
+      frame_,
+      media_log_.get(),
+      base::Bind(&WebMediaPlayerImpl::NotifyDownloading, AsWeakPtr())));
   data_source_->Initialize(
       url, static_cast<BufferedResourceLoader::CORSMode>(cors_mode),
       base::Bind(
           &WebMediaPlayerImpl::DataSourceInitialized,
           AsWeakPtr(), gurl));
 
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
 }
 
 void WebMediaPlayerImpl::load(const WebKit::WebURL& url,
@@ skipping 272 matching lines @@
   }
 
   // Avoid locking and potentially blocking the video rendering thread while
   // painting in software.
   scoped_refptr<media::VideoFrame> video_frame;
   {
     base::AutoLock auto_lock(lock_);
     video_frame = current_frame_;
   }
   gfx::Rect gfx_rect(rect);
-  skcanvas_video_renderer_.Paint(video_frame, canvas, gfx_rect, alpha);
+  skcanvas_video_renderer_.Paint(video_frame.get(), canvas, gfx_rect, alpha);
 }
 
 bool WebMediaPlayerImpl::hasSingleSecurityOrigin() const {
   if (data_source_)
     return data_source_->HasSingleOrigin();
   return true;
 }
 
 bool WebMediaPlayerImpl::didPassCORSAccessCheck() const {
   if (data_source_)
@@ skipping 71 matching lines @@
     unsigned int level,
     unsigned int internal_format,
     unsigned int type,
     bool premultiply_alpha,
     bool flip_y) {
   scoped_refptr<media::VideoFrame> video_frame;
   {
     base::AutoLock auto_lock(lock_);
     video_frame = current_frame_;
   }
-  if (video_frame &&
+  if (video_frame.get() &&
       video_frame->format() == media::VideoFrame::NATIVE_TEXTURE &&
       video_frame->texture_target() == GL_TEXTURE_2D) {
     uint32 source_texture = video_frame->texture_id();
     // The video is stored in a unmultiplied format, so premultiply
     // if necessary.
     web_graphics_context->pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM,
         premultiply_alpha);
     // Application itself needs to take care of setting the right flip_y
     // value down to get the expected result.
     // flip_y==true means to reverse the video orientation while
@@ skipping 442 matching lines @@
   ScopedVector<media::AudioDecoder> audio_decoders;
   audio_decoders.push_back(new media::FFmpegAudioDecoder(
       media_thread_.message_loop_proxy()));
   if (cmd_line->HasSwitch(switches::kEnableOpusPlayback)) {
     audio_decoders.push_back(new media::OpusAudioDecoder(
         media_thread_.message_loop_proxy()));
   }
 
   scoped_ptr<media::AudioRenderer> audio_renderer(
       new media::AudioRendererImpl(media_thread_.message_loop_proxy(),
-                                   audio_source_provider_,
+                                   audio_source_provider_.get(),
                                    audio_decoders.Pass(),
                                    set_decryptor_ready_cb));
   filter_collection->SetAudioRenderer(audio_renderer.Pass());
 
   // Create our video decoders and renderer.
   ScopedVector<media::VideoDecoder> video_decoders;
 
-  if (gpu_factories_) {
+  if (gpu_factories_.get()) {
     video_decoders.push_back(new media::GpuVideoDecoder(
         media_thread_.message_loop_proxy(), gpu_factories_));
   }
 
   // TODO(phajdan.jr): Remove ifdefs when libvpx with vp9 support is released
   // (http://crbug.com/174287) .
 #if !defined(MEDIA_DISABLE_LIBVPX)
   if (cmd_line->HasSwitch(switches::kEnableVp9Playback) ||
       cmd_line->HasSwitch(switches::kEnableVp8AlphaPlayback)) {
     video_decoders.push_back(new media::VpxVideoDecoder(
@@ skipping 51 matching lines @@
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Abort any pending IO so stopping the pipeline doesn't get blocked.
   if (data_source_)
     data_source_->Abort();
   if (chunk_demuxer_) {
     chunk_demuxer_->Shutdown();
     chunk_demuxer_ = NULL;
   }
 
-  if (gpu_factories_) {
+  if (gpu_factories_.get()) {
     gpu_factories_->Abort();
     gpu_factories_ = NULL;
   }
 
   // Make sure to kill the pipeline so there's no more media threads running.
   // Note: stopping the pipeline might block for a long time.
   base::WaitableEvent waiter(false, false);
   pipeline_->Stop(base::Bind(
       &base::WaitableEvent::Signal, base::Unretained(&waiter)));
   waiter.Wait();
@@ skipping 12 matching lines @@
   data_source_.reset();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(client_);
   return client_;
 }
 
 WebKit::WebAudioSourceProvider* WebMediaPlayerImpl::audioSourceProvider() {
-  return audio_source_provider_;
+  return audio_source_provider_.get();
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 double WebMediaPlayerImpl::GetPipelineDuration() const {
   base::TimeDelta duration = pipeline_->GetMediaDuration();
@@ skipping 10 matching lines @@
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return;
 
   GetClient()->durationChanged();
 }
 
 void WebMediaPlayerImpl::FrameReady(
     const scoped_refptr<media::VideoFrame>& frame) {
   base::AutoLock auto_lock(lock_);
 
-  if (current_frame_ &&
+  if (current_frame_.get() &&
       current_frame_->natural_size() != frame->natural_size() &&
       !pending_size_change_) {
     pending_size_change_ = true;
   }
 
   current_frame_ = frame;
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media