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()) {
+    media_log_->AddEvent(
+        media_log_->CreateBufferedExtentsChangedEvent(
+            offset_ - buffer_->backward_bytes(),
+            offset_,
+            offset_ + buffer_->forward_bytes()));
+  }
+}
+
 }  // namespace webkit_glue