Log BufferedResourceLoader events to MediaLog.

webkit/glue/media/buffered_resource_loader.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_resource_loader.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
+#include "media/base/media_log.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKitClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoaderOptions.h"
 #include "webkit/glue/multipart_response_delegate.h"
 #include "webkit/glue/webkit_glue.h"
 
@@ skipping 27 matching lines @@
 
 // Maximum number of bytes outside the buffer we will wait for in order to
 // fulfill a read. If a read starts more than 2MB away from the data we
 // currently have in the buffer, we will not wait for buffer to reach the read's
 // location and will instead reset the request.
 static const int kForwardWaitThreshold = 2 * kMegabyte;
 
 BufferedResourceLoader::BufferedResourceLoader(
     const GURL& url,
     int64 first_byte_position,
-    int64 last_byte_position)
+    int64 last_byte_position,
+    media::MediaLog* media_log)
     : buffer_(new media::SeekableBuffer(kBackwardCapacity, kForwardCapacity)),
       deferred_(false),
       defer_strategy_(kReadThenDefer),
       completed_(false),
       range_requested_(false),
       range_supported_(false),
       saved_forward_capacity_(0),
       url_(url),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       single_origin_(true),
       start_callback_(NULL),
       offset_(0),
       content_length_(kPositionNotSpecified),
       instance_size_(kPositionNotSpecified),
       read_callback_(NULL),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       first_offset_(0),
       last_offset_(0),
-      keep_test_loader_(false) {
+      keep_test_loader_(false),
+      media_log_(media_log) {
 }
 
 BufferedResourceLoader::~BufferedResourceLoader() {
   if (!completed_ && url_loader_.get())
     url_loader_->cancel();
 }
 
 void BufferedResourceLoader::Start(net::CompletionCallback* start_callback,
                                    NetworkEventCallback* event_callback,
                                    WebFrame* frame) {
@@ skipping 302 matching lines @@
   // Consume excess bytes from our in-memory buffer if necessary.
   if (buffer_->forward_bytes() > buffer_->forward_capacity()) {
     size_t 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();
+  Log();
 }
 
 void BufferedResourceLoader::didDownloadData(
     WebKit::WebURLLoader* loader,
     int dataLength) {
   NOTIMPLEMENTED();
 }
 
 void BufferedResourceLoader::didReceiveCachedMetadata(
     WebURLLoader* loader,
@@ skipping 258 matching lines @@
   read_callback_.reset();
   if (buffer_.get() && saved_forward_capacity_) {
     buffer_->set_forward_capacity(saved_forward_capacity_);
     saved_forward_capacity_ = 0;
   }
   read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = NULL;
   first_offset_ = 0;
   last_offset_ = 0;
+  Log();
 }
 
 void BufferedResourceLoader::DoneStart(int error) {
   start_callback_->RunWithParams(Tuple1<int>(error));
   start_callback_.reset();
 }
 
 void BufferedResourceLoader::NotifyNetworkEvent() {
   if (event_callback_.get())
     event_callback_->Run();
 }
 
 bool BufferedResourceLoader::IsRangeRequest() const {
   return first_byte_position_ != kPositionNotSpecified;
 }
 
+void BufferedResourceLoader::Log() {
+  if (buffer_.get()) {

[scherkus (not reviewing), 2011/08/08 23:18:25]

so is media_log a required param or not?

if it's refcounted, when would it be NULL?

[Scott Franklin, 2011/08/09 00:27:27]

That's a check for buffer_, which is null surprisingly often. At this point the
check is only necessary on the second Log() invocation above, so it could go
there instead, but that could conceivably change in the future.

+    media_log_->SetBufferedExtents(offset_ - buffer_->backward_bytes(),
+                                   offset_,
+                                   offset_ + buffer_->forward_bytes());
+  }
+}
+
 }  // namespace webkit_glue