Only make Range requests when the desired range doesn't cover the whole file.

webkit/glue/media/buffered_data_source.cc

 // Copyright (c) 2011 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/glue/media/buffered_data_source.h"
 
 #include "media/base/filter_host.h"
 #include "net/base/net_errors.h"
 #include "webkit/glue/media/web_data_source_factory.h"
 #include "webkit/glue/webkit_glue.h"
@@ skipping 440 matching lines @@
   initialize_callback->Run(status);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader callback methods.
 void BufferedDataSource::HttpInitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   int64 instance_size = loader_->instance_size();
-  bool partial_response = loader_->partial_response();
   bool success = error == net::OK;
 
   if (!initialize_callback_.get()) {
     loader_->Stop();
     return;
   }
 
   if (success) {
     // TODO(hclam): Needs more thinking about supporting servers without range
     // request or their partial response is not complete.
     total_bytes_ = instance_size;
     loaded_ = false;
-    streaming_ = (instance_size == kPositionNotSpecified) || !partial_response;
+    streaming_ = (instance_size == kPositionNotSpecified) ||
+        !loader_->range_supported();
   } else {
     // TODO(hclam): In case of failure, we can retry several times.
     loader_->Stop();
   }
 
   if (error == net::ERR_INVALID_RESPONSE && using_range_request_) {
     // Assuming that the Range header was causing the problem. Retry without
     // the Range header.
     using_range_request_ = false;
     loader_ = CreateResourceLoader(kPositionNotSpecified,
@@ skipping 80 matching lines @@
 
     UpdateHostState();
     DoneInitialization_Locked(media::PIPELINE_OK);
   }
 }
 
 void BufferedDataSource::PartialReadStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
-  // This callback method is invoked after we have verified the server has
-  // range request capability, so as a safety guard verify again the response
-  // is partial.
-  if (error == net::OK && loader_->partial_response()) {
-    // Once the range request has started successfully, we can proceed with
+  if (error == net::OK) {

[acolwell GONE FROM CHROMIUM, 2011/04/07 22:56:48]

loader_->partial_response() is not needed here anymore because the loader will
return an error code if a range was requested and we didn't get a partial
response.

+    // Once the request has started successfully, we can proceed with
     // reading from it.
     ReadInternal();
     return;
   }
 
   // Stop the resource loader since we have received an error.
   loader_->Stop();
 
   // 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
@@ skipping 34 matching lines @@
   // 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 (error > 0) {
     // If a position error code is received, read was successful. So copy
     // from intermediate read buffer to the target read buffer.
     memcpy(read_buffer_, intermediate_read_buffer_.get(), error);
+  } else if (error == 0 && total_bytes_ == kPositionNotSpecified) {
+    // We've reached the end of the file and we didn't know the total size
+    // before. Update the total size so Read()s past the end of the file will
+    // fail like they would if we had known the file size at the beginning.
+    total_bytes_ = loader_->instance_size();
+
+    if (total_bytes_ != kPositionNotSpecified)
+      host()->SetTotalBytes(total_bytes_);

[Ami GONE FROM CHROMIUM, 2011/04/08 03:02:10]

Do you not need to check that host()!=NULL?

[acolwell GONE FROM CHROMIUM, 2011/04/18 22:09:56]

Done.

   }
   DoneRead_Locked(error);
 }
 
 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.
@@ skipping 39 matching lines @@
 
   if (streaming_) {
     filter_host->SetStreaming(true);
   } else {
     filter_host->SetTotalBytes(total_bytes_);
     filter_host->SetBufferedBytes(buffered_bytes_);
   }
 }
 
 }  // namespace webkit_glue