Write file:// tests for BufferedDataSource and fix some bugs as a result.

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"
@@ skipping 22 matching lines @@
 }
 static void NonHttpProgressCallback(int64) {}
 
 BufferedDataSource::BufferedDataSource(
     MessageLoop* render_loop,
     WebFrame* frame,
     media::MediaLog* media_log,
     const DownloadingCB& downloading_cb)
     : cors_mode_(BufferedResourceLoader::kUnspecified),
       total_bytes_(kPositionNotSpecified),
-      buffered_bytes_(0),
+      assume_fully_buffered_(false),
       streaming_(false),
       frame_(frame),
       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),
@@ skipping 227 matching lines @@
   loader_.reset(
       CreateResourceLoader(last_read_start_, kPositionNotSpecified));
   if (url_.SchemeIs(kHttpScheme) || url_.SchemeIs(kHttpsScheme)) {
     loader_->Start(
         base::Bind(&BufferedDataSource::PartialReadStartCallback, this),
         base::Bind(&BufferedDataSource::HttpLoadingStateChangedCallback, this),
         base::Bind(&BufferedDataSource::HttpProgressCallback, this),
         frame_);
   } else {
     loader_->Start(
-        base::Bind(&BufferedDataSource::NonHttpInitialStartCallback, this),
+        base::Bind(&BufferedDataSource::PartialReadStartCallback, this),
         base::Bind(&NonHttpLoadingStateChangedCallback),
         base::Bind(&NonHttpProgressCallback),
         frame_);
   }
 }
 
 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
@@ skipping 143 matching lines @@
     loader_->Stop();
     return;
   }
 
   int64 instance_size = loader_->instance_size();
   bool success = status == BufferedResourceLoader::kOk &&
      instance_size != kPositionNotSpecified;
 
   if (success) {
     total_bytes_ = instance_size;
-    buffered_bytes_ = total_bytes_;
+    assume_fully_buffered_ = true;
   } else {
     loader_->Stop();
   }
 
   // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   // TODO: Review locking in this class and figure out a way to run the callback
   //       w/o the lock.
   scoped_refptr<BufferedDataSource> destruction_guard(this);
@@ skipping 134 matching lines @@
   if (host() && position > last_read_start_)
     host()->AddBufferedByteRange(last_read_start_, position);
 }
 
 void BufferedDataSource::UpdateHostState_Locked() {
   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_);
+  if (total_bytes_ == kPositionNotSpecified)
+    return;
+
+  host()->SetTotalBytes(total_bytes_);
+
+  if (assume_fully_buffered_)
+    host()->AddBufferedByteRange(0, total_bytes_);
 }
 
 }  // namespace webkit_media