make multibuffer work with layout tests

media/blink/multibuffer_data_source.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 "media/blink/multibuffer_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 158 matching lines @@
 
   // We're not allowed to call Wait() if data is already available.
   if (reader_->Available()) {
     render_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&MultibufferDataSource::StartCallback, weak_ptr_));
   } else {
     reader_->Wait(1,
                   base::Bind(&MultibufferDataSource::StartCallback, weak_ptr_));
   }
-  UpdateLoadingState();
 }
 
 void MultibufferDataSource::OnRedirect(
     const scoped_refptr<UrlData>& destination) {
   if (!destination) {
     // A failure occured.
     if (!init_cb_.is_null()) {
       render_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&MultibufferDataSource::StartCallback, weak_ptr_));
@@ skipping 33 matching lines @@
             FROM_HERE, base::Bind(&MultibufferDataSource::ReadTask, weak_ptr_));
       } else {
         reader_->Wait(1,
                       base::Bind(&MultibufferDataSource::ReadTask, weak_ptr_));
       }
     }
   }
 }
 
 void MultibufferDataSource::SetPreload(Preload preload) {
+  DVLOG(1) << __FUNCTION__ << "(" << preload << ")";
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   preload_ = preload;
   UpdateBufferSizes();
 }
 
 void MultibufferDataSource::SetBufferingStrategy(
     BufferingStrategy buffering_strategy) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   buffering_strategy_ = buffering_strategy;
   UpdateBufferSizes();
@@ skipping 143 matching lines @@
     return;
   }
   if (available) {
     bytes_read =
         static_cast<int>(std::min<int64_t>(available, read_op_->size()));
     bytes_read = reader_->TryRead(read_op_->data(), bytes_read);
     ReadOperation::Run(read_op_.Pass(), bytes_read);
   } else {
     reader_->Wait(1, base::Bind(&MultibufferDataSource::ReadTask,
                                 weak_factory_.GetWeakPtr()));
-    UpdateLoadingState();
+    UpdateLoadingState(false);
   }
 }
 
 void MultibufferDataSource::StopInternal_Locked() {
   lock_.AssertAcquired();
   if (stop_signal_received_)
     return;
 
   stop_signal_received_ = true;
 
@@ skipping 62 matching lines @@
 
     // Progress callback might be called after the start callback,
     // make sure that we update single_origin_ now.
     media_log_->SetBooleanProperty("single_origin", single_origin_);
     media_log_->SetBooleanProperty("passed_cors_access_check",
                                    DidPassCORSAccessCheck());
     media_log_->SetBooleanProperty("range_header_supported",
                                    url_data_->range_supported());
   }
 
-  UpdateLoadingState();
   render_task_runner_->PostTask(
       FROM_HERE, base::Bind(base::ResetAndReturn(&init_cb_), success));
+
+  // Even if data is cached, say that we're loading at this point for
+  // compatibility.
+  UpdateLoadingState(true);
 }
 
 void MultibufferDataSource::ProgressCallback(int64 begin, int64 end) {
+  DVLOG(1) << __FUNCTION__ << "(" << begin << ", " << end << ")";
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (assume_fully_buffered())
     return;
 
   if (end > begin) {
     // TODO(scherkus): we shouldn't have to lock to signal host(), see
     // http://crbug.com/113712 for details.
     base::AutoLock auto_lock(lock_);
     if (stop_signal_received_)
       return;
 
     host_->AddBufferedByteRange(begin, end);
   }
 
-  UpdateLoadingState();
+  UpdateLoadingState(false);
 }
 
-void MultibufferDataSource::UpdateLoadingState() {
+void MultibufferDataSource::UpdateLoadingState(bool force_loading) {
+  DVLOG(1) << __FUNCTION__;
+  if (assume_fully_buffered())
+    return;
   // Update loading state.
-  if ((!!reader_ && reader_->IsLoading()) != loading_) {
-    loading_ = !loading_;
+  bool is_loading = !!reader_ && reader_->IsLoading();
+  if (force_loading || is_loading != loading_) {
+    loading_ = is_loading || force_loading;
 
     if (!loading_ && cancel_on_defer_) {
       reader_.reset(nullptr);
     }
 
     // Callback could kill us, be sure to call it last.
     downloading_cb_.Run(loading_);
   }
 }
 
 void MultibufferDataSource::UpdateBufferSizes() {
+  DVLOG(1) << __FUNCTION__;
   if (!reader_)
     return;
 
   if (!assume_fully_buffered()) {
     // If the playback has started and the strategy is aggressive, then try to
     // load as much as possible, assuming that the file is cacheable. (If not,
     // why bother?)
     bool aggressive = (buffering_strategy_ == BUFFERING_STRATEGY_AGGRESSIVE);
     if (media_has_played_ && aggressive && url_data_ &&
         url_data_->range_supported() && url_data_->cacheable()) {
@@ skipping 25 matching lines @@
   reader_->SetMaxBuffer(back_buffer, pin_forwards);
 
   if (preload_ == METADATA) {
     reader_->SetPreload(0, 0);
   } else {
     reader_->SetPreload(preload + kPreloadHighExtra, preload);
   }
 }
 
 }  // namespace media