Stop using WebMediaPlayerClient::preload() and volume()

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 <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 69 matching lines @@
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     media::MediaLog* media_log,
     scoped_ptr<MediaStreamRendererFactory> factory)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       buffered_(static_cast<size_t>(1)),
+      volume_(1.0f),
       client_(client),
       delegate_(delegate),
       paused_(true),
       current_frame_used_(false),
       pending_repaint_(false),
       video_frame_provider_client_(NULL),
       received_first_frame_(false),
       total_frame_count_(0),
       dropped_frame_count_(0),
       media_log_(media_log),
@@ skipping 28 matching lines @@
                             CORSMode cors_mode) {
   DVLOG(1) << "WebMediaPlayerMS::load";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(acolwell): Change this to DCHECK_EQ(load_type,
   // LoadTypeMediaStream) once Blink-side changes land.
   DCHECK_NE(load_type, LoadTypeMediaSource);
 
   GURL gurl(url);
 
-  setVolume(GetClient()->volume());
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 
   video_frame_provider_ = renderer_factory_->GetVideoFrameProvider(
       url,
       base::Bind(&WebMediaPlayerMS::OnSourceError, AsWeakPtr()),
       base::Bind(&WebMediaPlayerMS::OnFrameAvailable, AsWeakPtr()));
 
   RenderFrame* frame = RenderFrame::FromWebFrame(frame_);
   audio_renderer_ = renderer_factory_->GetAudioRenderer(
     url,
     frame->GetRenderView()->GetRoutingID(),
     frame->GetRoutingID());
 
   if (video_frame_provider_.get() || audio_renderer_.get()) {
-    if (audio_renderer_.get())
+    if (audio_renderer_.get()) {
+      audio_renderer_->SetVolume(volume_);
       audio_renderer_->Start();
+    }
 
     if (video_frame_provider_.get()) {
       video_frame_provider_->Start();
     } else {
       // This is audio-only mode.
       DCHECK(audio_renderer_.get());
       SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
       SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
     }
   } else {
@@ skipping 60 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_.get())
-    return;
   DVLOG(1) << "WebMediaPlayerMS::setVolume(volume=" << volume << ")";
-  audio_renderer_->SetVolume(volume);
+  volume_ = volume;
+  if (audio_renderer_.get())
+    audio_renderer_->SetVolume(volume_);
 }
 
 void WebMediaPlayerMS::setPreload(WebMediaPlayer::Preload preload) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool WebMediaPlayerMS::hasVideo() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return (video_frame_provider_.get() != NULL);
 }
@@ skipping 218 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 blink::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace content