Remove WebMediaPlayerImpl::GetClient() because it's useless.

content/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 "content/renderer/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 186 matching lines @@
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink().get()
           ? params.audio_renderer_sink()
           : new media::NullAudioSink(media_loop_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   SetVideoFrameProviderClient(NULL);
-  GetClient()->setWebLayer(NULL);
+  client_->setWebLayer(NULL);
 
   DCHECK(main_loop_->BelongsToCurrentThread());
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_.get())
     delegate_->PlayerGone(this);
 
   Destroy();
 }
@@ skipping 49 matching lines @@
 
   GURL gurl(url);
   UMA_HISTOGRAM_ENUMERATION("Media.URLScheme", URLScheme(gurl), kMaxURLScheme);
 
   // Set subresource URL for crash reporting.
   base::debug::SetCrashKeyValue("subresource_url", gurl.spec());
 
   load_type_ = load_type;
 
   // Handle any volume/preload changes that occurred before load().
-  setVolume(GetClient()->volume());
-  setPreload(GetClient()->preload());
+  setVolume(client_->volume());
+  setPreload(client_->preload());
 
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 
   // Media source pipelines can start immediately.
   if (load_type == LoadTypeMediaSource) {
     supports_save_ = false;
     StartPipeline();
     return;
@@ skipping 578 matching lines @@
     std::swap(pending_size_change_, size_changed);
     if (pending_repaint_) {
       TRACE_EVENT_ASYNC_END0(
           "media", "WebMediaPlayerImpl:repaintPending", this);
       pending_repaint_ = false;
     }
   }
 
   if (size_changed) {
     TRACE_EVENT0("media", "WebMediaPlayerImpl:clientSizeChanged");
-    GetClient()->sizeChanged();
+    client_->sizeChanged();
   }
 
   TRACE_EVENT0("media", "WebMediaPlayerImpl:clientRepaint");
-  GetClient()->repaint();
+  client_->repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineSeek(PipelineStatus status) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   starting_ = false;
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_seconds_);
     return;
   }
 
   if (status != media::PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
   // Update our paused time.
   if (paused_)
     paused_time_ = pipeline_->GetMediaTime();
 
-  GetClient()->timeChanged();
+  client_->timeChanged();
 }
 
 void WebMediaPlayerImpl::OnPipelineEnded() {
   DCHECK(main_loop_->BelongsToCurrentThread());
-  GetClient()->timeChanged();
+  client_->timeChanged();
 }
 
 void WebMediaPlayerImpl::OnPipelineError(PipelineStatus error) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK_NE(error, media::PIPELINE_OK);
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing) {
     // Any error that occurs before reaching ReadyStateHaveMetadata should
     // be considered a format error.
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
@@ skipping 11 matching lines @@
 }
 
 void WebMediaPlayerImpl::OnPipelineBufferingState(
     media::Pipeline::BufferingState buffering_state) {
   DVLOG(1) << "OnPipelineBufferingState(" << buffering_state << ")";
 
   switch (buffering_state) {
     case media::Pipeline::kHaveMetadata:
       SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
-      if (hasVideo() && GetClient()->needsWebLayerForVideo()) {
+      if (hasVideo() && client_->needsWebLayerForVideo()) {
         DCHECK(!video_weblayer_);
         video_weblayer_.reset(
             new webkit::WebLayerImpl(cc::VideoLayer::Create(this)));
-        GetClient()->setWebLayer(video_weblayer_.get());
+        client_->setWebLayer(video_weblayer_.get());
       }
       break;
     case media::Pipeline::kPrerollCompleted:
       // Only transition to ReadyStateHaveEnoughData if we don't have
       // any pending seeks because the transition can cause Blink to
       // report that the most recent seek has completed.
       if (!pending_seek_)
         SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK(main_loop_->BelongsToCurrentThread());
-  GetClient()->mediaSourceOpened(new WebMediaSourceImpl(
+  client_->mediaSourceOpened(new WebMediaSourceImpl(
       chunk_demuxer_, base::Bind(&LogMediaSourceError, media_log_)));
 }
 
 void WebMediaPlayerImpl::OnKeyAdded(const std::string& session_id) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   EmeUMAHistogramCounts(current_key_system_, "KeyAdded", 1);
-  GetClient()->keyAdded(current_key_system_,
-                        WebString::fromUTF8(session_id));
+  client_->keyAdded(current_key_system_, WebString::fromUTF8(session_id));
 }
 
 void WebMediaPlayerImpl::OnNeedKey(const std::string& type,
                                    const std::vector<uint8>& init_data) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Do not fire NeedKey event if encrypted media is not enabled.
   if (!decryptor_)
     return;
 
   UMA_HISTOGRAM_COUNTS(kMediaEme + std::string("NeedKey"), 1);
 
   DCHECK(init_data_type_.empty() || type.empty() || type == init_data_type_);
   if (init_data_type_.empty())
     init_data_type_ = type;
 
   const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
-  GetClient()->keyNeeded(WebString(),
-                         WebString(),
-                         init_data_ptr,
-                         init_data.size());
+  client_->keyNeeded(WebString(), WebString(), init_data_ptr, init_data.size());
 }
 
 void WebMediaPlayerImpl::OnAddTextTrack(
     const media::TextTrackConfig& config,
     const media::AddTextTrackDoneCB& done_cb) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   const WebInbandTextTrackImpl::Kind web_kind =
       static_cast<WebInbandTextTrackImpl::Kind>(config.kind());
   const blink::WebString web_label =
       blink::WebString::fromUTF8(config.label());
   const blink::WebString web_language =
       blink::WebString::fromUTF8(config.language());
   const blink::WebString web_id =
       blink::WebString::fromUTF8(config.id());
 
   scoped_ptr<WebInbandTextTrackImpl> web_inband_text_track(
       new WebInbandTextTrackImpl(web_kind, web_label, web_language, web_id,
                                  text_track_index_++));
 
   scoped_ptr<media::TextTrack> text_track(
-      new TextTrackImpl(main_loop_, GetClient(), web_inband_text_track.Pass()));
+      new TextTrackImpl(main_loop_, client_, web_inband_text_track.Pass()));
 
   done_cb.Run(text_track.Pass());
 }
 
 void WebMediaPlayerImpl::OnKeyError(const std::string& session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
                              error_code, media::MediaKeys::kMaxKeyError);
 
-  GetClient()->keyError(
+  client_->keyError(
       current_key_system_,
       WebString::fromUTF8(session_id),
       static_cast<blink::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
       system_code);
 }
 
 void WebMediaPlayerImpl::OnKeyMessage(const std::string& session_id,
                                       const std::vector<uint8>& message,
                                       const std::string& default_url) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   const GURL default_url_gurl(default_url);
   DLOG_IF(WARNING, !default_url.empty() && !default_url_gurl.is_valid())
       << "Invalid URL in default_url: " << default_url;
 
-  GetClient()->keyMessage(current_key_system_,
-                          WebString::fromUTF8(session_id),
-                          message.empty() ? NULL : &message[0],
-                          message.size(),
-                          default_url_gurl);
+  client_->keyMessage(current_key_system_,
+                      WebString::fromUTF8(session_id),
+                      message.empty() ? NULL : &message[0],
+                      message.size(),
+                      default_url_gurl);
 }
 
 void WebMediaPlayerImpl::SetOpaque(bool opaque) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
-  GetClient()->setOpaque(opaque);
+  client_->setOpaque(opaque);
 }
 
 void WebMediaPlayerImpl::DataSourceInitialized(const GURL& gurl, bool success) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (!success) {
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
     Repaint();
     return;
   }
@@ skipping 106 matching lines @@
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineBufferingState),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDurationChange));
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "SetNetworkState: " << state;
   network_state_ = state;
   // Always notify to ensure client has the latest value.
-  GetClient()->networkStateChanged();
+  client_->networkStateChanged();
 }
 
 void WebMediaPlayerImpl::SetReadyState(WebMediaPlayer::ReadyState state) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "SetReadyState: " << state;
 
   if (state == WebMediaPlayer::ReadyStateHaveEnoughData &&
       is_local_source_ &&
       network_state_ == WebMediaPlayer::NetworkStateLoading)
     SetNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   ready_state_ = state;
   // Always notify to ensure client has the latest value.
-  GetClient()->readyStateChanged();
+  client_->readyStateChanged();
 }
 
 void WebMediaPlayerImpl::Destroy() {
   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();
@@ skipping 18 matching lines @@
         -kPlayerExtraMemory);
     incremented_externally_allocated_memory_ = false;
   }
 
   // Release any final references now that everything has stopped.
   pipeline_.reset();
   demuxer_.reset();
   data_source_.reset();
 }
 
-blink::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
-  DCHECK(main_loop_->BelongsToCurrentThread());

[Ami GONE FROM CHROMIUM, 2013/12/19 21:00:50]

This is the only bit I (slightly) regret losing with this CL: previously this
enforced that only the main thread accessed client_ but now all callers need to
know.

Clearly the time has come for SingleThreadedUnownedPointer!

(you could use a WeakPtr for this but that probably cross the
crazy-event-horizon; also you could sprinkle WebMediaPlayerClientImpl's public
methods with ASSERT(isOnMainThread())'s, and that might actually make sense, I'm
not sure).

[scherkus (not reviewing), 2013/12/19 21:14:10]

that assumes future coders realize they should be using GetClient() versus
client_ :P
if anything I'd do the WebMediaPlayerClientImpl change ... but I feel it's
getting overly paranoid considering it's blink code at that point which mostly
runs on the main thread by convention

-  DCHECK(client_);
-  return client_;
-}
-
 blink::WebAudioSourceProvider* WebMediaPlayerImpl::audioSourceProvider() {
   return audio_source_provider_.get();
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   incremented_externally_allocated_memory_ = true;
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
       kPlayerExtraMemory);
 }
 
 double WebMediaPlayerImpl::GetPipelineDuration() const {
   base::TimeDelta duration = pipeline_->GetMediaDuration();
 
   // Return positive infinity if the resource is unbounded.
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/video.html#dom-media-duration
   if (duration == media::kInfiniteDuration())
     return std::numeric_limits<double>::infinity();
 
   return duration.InSecondsF();
 }
 
 void WebMediaPlayerImpl::OnDurationChange() {
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return;
 
-  GetClient()->durationChanged();
+  client_->durationChanged();
 }
 
 void WebMediaPlayerImpl::FrameReady(
     const scoped_refptr<media::VideoFrame>& frame) {
   base::AutoLock auto_lock(lock_);
 
   if (current_frame_ &&
       current_frame_->natural_size() != frame->natural_size() &&
       !pending_size_change_) {
     pending_size_change_ = true;
@@ skipping 34 matching lines @@
   // The |current_frame_| wasn't painted, it is being replaced, and we haven't
   // even gotten the chance to request a repaint for it yet. Mark it as dropped.
   TRACE_EVENT0("media", "WebMediaPlayerImpl:frameDropped");
   DVLOG(1) << "Frame dropped before being painted: "
            << current_frame_->GetTimestamp().InSecondsF();
   if (frames_dropped_before_paint_ < kuint32max)
     frames_dropped_before_paint_++;
 }
 
 }  // namespace content