Replace Pipeline::SetNetworkActivity() with BufferedDataSource -> WebMediaPlayerImpl callback.

webkit/media/webmediaplayer_impl.cc

 // Copyright (c) 2012 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/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include "webkit/media/webmediaplayer_delegate.h"
 #include "webkit/media/webmediaplayer_proxy.h"
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webvideoframe_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebMediaPlayer;
 using WebKit::WebRect;
 using WebKit::WebSize;
 using WebKit::WebString;
-using media::NetworkEvent;
 using media::PipelineStatus;
 
 namespace {
 
 // Amount of extra memory used by each player instance reported to V8.
 // It is not exact number -- first, it differs on different platforms,
 // and second, it is very hard to calculate. Instead, use some arbitrary
 // value that will cause garbage collection from time to time. We don't want
 // it to happen on every allocation, but don't want 5k players to sit in memory
 // either. Looks that chosen constant achieves both goals, at least for audio
@@ skipping 179 matching lines @@
                                  filter_collection_.get(),
                                  decryptor_.get(),
                                  &video_decoder)) {
     proxy_->set_video_decoder(video_decoder);
     StartPipeline();
     return;
   }
 
   // Otherwise it's a regular request which requires resolving the URL first.
   proxy_->set_data_source(
-      new BufferedDataSource(main_loop_, frame_, media_log_));
+      new BufferedDataSource(main_loop_, frame_, media_log_,
+                             base::Bind(&WebMediaPlayerImpl::NotifyDownloading,
+                                        base::Unretained(this))));
   proxy_->data_source()->Initialize(
       url, static_cast<BufferedResourceLoader::CORSMode>(cors_mode),
       base::Bind(
           &WebMediaPlayerImpl::DataSourceInitialized,
           base::Unretained(this), gurl));
 
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
 
   BuildDefaultCollection(proxy_->data_source(),
                          message_loop_factory_.get(),
@@ skipping 193 matching lines @@
 }
 
 int WebMediaPlayerImpl::dataRate() const {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
   return 0;
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
+  DCHECK_EQ(main_loop_, MessageLoop::current());
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
+  DCHECK_EQ(main_loop_, MessageLoop::current());
   return ready_state_;
 }
 
 const WebKit::WebTimeRanges& WebMediaPlayerImpl::buffered() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   media::Ranges<base::TimeDelta> buffered_time_ranges =
       pipeline_->GetBufferedTimeRanges();
   WebKit::WebTimeRanges web_ranges(buffered_time_ranges.size());
   for (size_t i = 0; i < buffered_time_ranges.size(); ++i) {
     web_ranges[i].start = buffered_time_ranges.start(i).InSecondsF();
@@ skipping 435 matching lines @@
       // TODO(xhwang): Change to use NetworkStateDecryptError once it's added in
       // Webkit (see http://crbug.com/124486).
       SetNetworkState(WebMediaPlayer::NetworkStateDecodeError);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
-void WebMediaPlayerImpl::OnNetworkEvent(NetworkEvent type) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
-  switch(type) {
-    case media::DOWNLOAD_CONTINUED:
-      SetNetworkState(WebMediaPlayer::NetworkStateLoading);
-      break;
-    case media::DOWNLOAD_PAUSED:
-      SetNetworkState(WebMediaPlayer::NetworkStateIdle);
-      break;
-    case media::CAN_PLAY_THROUGH:
-      // Temporarily disable delayed firing of CAN_PLAY_THROUGH due to
-      // crbug.com/106480.
-      // TODO(vrk): uncomment code below when bug above is fixed.
-      // SetReadyState(WebMediaPlayer::NetworkStateHaveEnoughData);
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GetClient()->sourceOpened();
 }
 
 void WebMediaPlayerImpl::OnKeyNeeded(scoped_array<uint8> init_data,
                                      int init_data_size) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
@@ skipping 14 matching lines @@
   if (status != media::PIPELINE_OK) {
     DVLOG(1) << "DataSourceInitialized status: " << status;
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
     Repaint();
     return;
   }
 
   StartPipeline();
 }
 
+void WebMediaPlayerImpl::NotifyDownloading(bool is_downloading) {
+  if (!is_downloading && network_state_ == WebMediaPlayer::NetworkStateLoading)
+    SetNetworkState(WebMediaPlayer::NetworkStateIdle);
+  else if (is_downloading && network_state_ == WebMediaPlayer::NetworkStateIdle)
+    SetNetworkState(WebMediaPlayer::NetworkStateLoading);
+  media_log_->AddEvent(
+      media_log_->CreateBooleanEvent(
+          media::MediaLogEvent::NETWORK_ACTIVITY_SET,
+          "is_downloading_data", is_downloading));
+}
+
 void WebMediaPlayerImpl::StartPipeline() {
   started_ = true;
   pipeline_->Start(
       filter_collection_.Pass(),
       base::Bind(&WebMediaPlayerProxy::PipelineEndedCallback, proxy_.get()),
       base::Bind(&WebMediaPlayerProxy::PipelineErrorCallback, proxy_.get()),
-      base::Bind(&WebMediaPlayerProxy::NetworkEventCallback, proxy_.get()),
       base::Bind(&WebMediaPlayerProxy::PipelineInitializationCallback,
                  proxy_.get()));
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   DVLOG(1) << "SetNetworkState: " << state;
   network_state_ = state;
   // Always notify to ensure client has the latest value.
   GetClient()->networkStateChanged();
@@ skipping 53 matching lines @@
   return audio_source_provider_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media