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

webkit/media/buffered_data_source.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/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
 
 using WebKit::WebFrame;
 
 namespace webkit_media {
 
 // BufferedDataSource has an intermediate buffer, this value governs the initial
 // size of that buffer. It is set to 32KB because this is a typical read size
 // of FFmpeg.
 static const int kInitialReadBufferSize = 32768;
 
 // Number of cache misses we allow for a single Read() before signalling an
 // error.
 static const int kNumCacheMissRetries = 3;
 
 BufferedDataSource::BufferedDataSource(
     MessageLoop* render_loop,
     WebFrame* frame,
-    media::MediaLog* media_log)
+    media::MediaLog* media_log,
+    const DownloadingCB& downloading_cb)
     : total_bytes_(kPositionNotSpecified),
       buffered_bytes_(0),
       streaming_(false),
       frame_(frame),
       loader_(NULL),
-      is_downloading_data_(false),
       read_size_(0),
       read_buffer_(NULL),
       last_read_start_(0),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
       stop_signal_received_(false),
       stopped_on_render_loop_(false),
       media_has_played_(false),
       preload_(AUTO),
       cache_miss_retries_left_(kNumCacheMissRetries),
       bitrate_(0),
       playback_rate_(0.0),
-      media_log_(media_log) {
+      media_log_(media_log),
+      downloading_cb_(downloading_cb) {
+  DCHECK(!downloading_cb_.is_null());
 }
 
 BufferedDataSource::~BufferedDataSource() {}
 
 // A factory method to create BufferedResourceLoader using the read parameters.
 // This method can be overrided to inject mock BufferedResourceLoader object
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
     int64 first_byte_position, int64 last_byte_position) {
   DCHECK(MessageLoop::current() == render_loop_);
@@ skipping 483 matching lines @@
 
 void BufferedDataSource::NetworkEventCallback() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   // In case of non-HTTP request we don't need to report network events,
   // so return immediately.
   if (!url_.SchemeIs(kHttpScheme) && !url_.SchemeIs(kHttpsScheme))
     return;
 
-  bool is_downloading_data = loader_->is_downloading_data();
+  downloading_cb_.Run(loader_->is_downloading_data());
+
   int64 current_buffered_position = loader_->GetBufferedPosition();
 
   // If we get an unspecified value, return immediately.
   if (current_buffered_position == kPositionNotSpecified)
     return;
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. So only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
   base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
-  if (is_downloading_data != is_downloading_data_) {
-    is_downloading_data_ = is_downloading_data;
-    if (host())
-      host()->SetNetworkActivity(is_downloading_data);
-  }
-
   int64 start = loader_->first_byte_position();
   if (host() && current_buffered_position > start)
     host()->AddBufferedByteRange(start, current_buffered_position);
 }
 
 void BufferedDataSource::UpdateHostState_Locked() {
   // Called from various threads, under lock.
   lock_.AssertAcquired();
 
   if (!host())
     return;
 
   if (total_bytes_ != kPositionNotSpecified)
     host()->SetTotalBytes(total_bytes_);
   int64 start = loader_->first_byte_position();
   if (buffered_bytes_ > start)
     host()->AddBufferedByteRange(start, buffered_bytes_);
 }
 
 }  // namespace webkit_media