Split BufferedResourceLoader's network callback into separate loading state and progress callbacks.

webkit/media/buffered_resource_loader.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_resource_loader.h"
 
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/metrics/histogram.h"
@@ skipping 126 matching lines @@
 
   // Set the initial capacity of |buffer_| based on |bitrate_| and
   // |playback_rate_|.
   UpdateBufferWindow();
 }
 
 BufferedResourceLoader::~BufferedResourceLoader() {}
 
 void BufferedResourceLoader::Start(
     const StartCB& start_cb,
-    const base::Closure& event_cb,
+    const LoadingStateChangedCB& loading_cb,
+    const ProgressCB& progress_cb,
     WebFrame* frame) {
   // Make sure we have not started.
   DCHECK(start_cb_.is_null());
-  DCHECK(event_cb_.is_null());
+  DCHECK(loading_cb_.is_null());
+  DCHECK(progress_cb_.is_null());
   DCHECK(!start_cb.is_null());
-  DCHECK(!event_cb.is_null());
+  DCHECK(!loading_cb.is_null());
+  DCHECK(!progress_cb.is_null());
   CHECK(frame);
 
   start_cb_ = start_cb;
-  event_cb_ = event_cb;
+  loading_cb_ = loading_cb;
+  progress_cb_ = progress_cb;
 
   if (first_byte_position_ != kPositionNotSpecified) {
     // TODO(hclam): server may not support range request so |offset_| may not
     // equal to |first_byte_position_|.
     offset_ = first_byte_position_;
   }
 
   // Prepare the request.
   WebURLRequest request(url_);
   request.setTargetType(WebURLRequest::TargetIsMedia);
@@ skipping 28 matching lines @@
           WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
       if (cors_mode_ == kUseCredentials)
         options.allowCredentials = true;
     }
     loader.reset(frame->createAssociatedURLLoader(options));
   }
 
   // Start the resource loading.
   loader->loadAsynchronously(request, this);
   active_loader_.reset(new ActiveLoader(loader.Pass()));
+  loading_cb_.Run(kLoading);
 }
 
 void BufferedResourceLoader::Stop() {
   // Reset callbacks.
   start_cb_.Reset();
-  event_cb_.Reset();
+  loading_cb_.Reset();
+  progress_cb_.Reset();
   read_cb_.Reset();
 
   // Cancel and reset any active loaders.
   active_loader_.reset();
 }
 
 void BufferedResourceLoader::Read(
     int64 position,
     int read_size,
     uint8* buffer,
@@ skipping 84 matching lines @@
     DCHECK(!ShouldEnableDefer())
         << "Capacity was not adjusted properly to prevent deferring.";
 
     return;
   }
 
   // Make a callback to report failure.
   DoneRead(kCacheMiss, 0);
 }
 
-int64 BufferedResourceLoader::GetBufferedPosition() {
-  return offset_ + buffer_.forward_bytes() - 1;
-}
-
 int64 BufferedResourceLoader::content_length() {
   return content_length_;
 }
 
 int64 BufferedResourceLoader::instance_size() {
   return instance_size_;
 }
 
 bool BufferedResourceLoader::range_supported() {
   return range_supported_;
 }
 
-bool BufferedResourceLoader::is_downloading_data() {
-  return active_loader_.get() && !active_loader_->deferred();
-}
-
 const GURL& BufferedResourceLoader::url() {
   return url_;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // WebKit::WebURLLoaderClient implementation.
 void BufferedResourceLoader::willSendRequest(
     WebURLLoader* loader,
     WebURLRequest& newRequest,
     const WebURLResponse& redirectResponse) {
@@ skipping 124 matching lines @@
   UpdateDeferBehavior();
 
   // Consume excess bytes from our in-memory buffer if necessary.
   if (buffer_.forward_bytes() > buffer_.forward_capacity()) {
     int excess = buffer_.forward_bytes() - buffer_.forward_capacity();
     bool success = buffer_.Seek(excess);
     DCHECK(success);
     offset_ += first_offset_ + excess;
   }
 
-  // Notify that we have received some data.
-  NotifyNetworkEvent();
+  // Notify latest progress and buffered offset.
+  progress_cb_.Run(offset_ + buffer_.forward_bytes() - 1);
   Log();
 }
 
 void BufferedResourceLoader::didDownloadData(
     WebKit::WebURLLoader* loader,
     int dataLength) {
   NOTIMPLEMENTED();
 }
 
 void BufferedResourceLoader::didReceiveCachedMetadata(
     WebURLLoader* loader,
     const char* data,
     int data_length) {
   NOTIMPLEMENTED();
 }
 
 void BufferedResourceLoader::didFinishLoading(
     WebURLLoader* loader,
     double finishTime) {
   DVLOG(1) << "didFinishLoading";
   DCHECK(active_loader_.get());
 
   // We're done with the loader.
   active_loader_.reset();
-  NotifyNetworkEvent();
+  loading_cb_.Run(kLoadingFinished);
 
   // If we didn't know the |instance_size_| we do now.
   if (instance_size_ == kPositionNotSpecified) {
     instance_size_ = offset_ + buffer_.forward_bytes();
   }
 
   // If there is a start callback, run it.
   if (!start_cb_.is_null()) {
     DCHECK(read_cb_.is_null())
         << "Shouldn't have a read callback during start";
@@ skipping 23 matching lines @@
            << ", domain=" << error.domain.utf8().data()
            << ", localizedDescription="
            << error.localizedDescription.utf8().data();
   DCHECK(active_loader_.get());
 
   // We don't need to continue loading after failure.
   //
   // Keep it alive until we exit this method so that |error| remains valid.
   scoped_ptr<ActiveLoader> active_loader = active_loader_.Pass();
   loader_failed_ = true;
-  NotifyNetworkEvent();
+  loading_cb_.Run(kLoadingFailed);
 
   // Don't leave start callbacks hanging around.
   if (!start_cb_.is_null()) {
     DCHECK(read_cb_.is_null())
         << "Shouldn't have a read callback during start";
     DoneStart(kFailed);
     return;
   }
 
   // Don't leave read callbacks hanging around.
@@ skipping 59 matching lines @@
     return;
 
   // If necessary, toggle defer state and continue/pause downloading data
   // accordingly.
   if (ShouldEnableDefer() || ShouldDisableDefer())
     SetDeferred(!active_loader_->deferred());
 }
 
 void BufferedResourceLoader::SetDeferred(bool deferred) {
   active_loader_->SetDeferred(deferred);
-  NotifyNetworkEvent();
+  loading_cb_.Run(deferred ? kLoadingDeferred : kLoading);
 }
 
 bool BufferedResourceLoader::ShouldEnableDefer() const {
   // If we're already deferring, then enabling makes no sense.
   if (active_loader_->deferred())
     return false;
 
   switch(defer_strategy_) {
     // Never defer at all, so never enable defer.
     case kNeverDefer:
@@ skipping 196 matching lines @@
   Log();
 
   base::ResetAndReturn(&read_cb_).Run(status, bytes_read);
 }
 
 
 void BufferedResourceLoader::DoneStart(Status status) {
   base::ResetAndReturn(&start_cb_).Run(status);
 }
 
-void BufferedResourceLoader::NotifyNetworkEvent() {
-  if (!event_cb_.is_null())
-    event_cb_.Run();
-}
-
 bool BufferedResourceLoader::IsRangeRequest() const {
   return first_byte_position_ != kPositionNotSpecified;
 }
 
 void BufferedResourceLoader::Log() {
   media_log_->AddEvent(
       media_log_->CreateBufferedExtentsChangedEvent(
           offset_ - buffer_.backward_bytes(),
           offset_,
           offset_ + buffer_.forward_bytes()));
 }
 
 }  // namespace webkit_media