Implementing preload=metadata for video

webkit/glue/media/buffered_resource_loader.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
 #ifndef WEBKIT_GLUE_MEDIA_BUFFERED_RESOURCE_LOADER_H_
 #define WEBKIT_GLUE_MEDIA_BUFFERED_RESOURCE_LOADER_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/scoped_ptr.h"
 #include "base/timer.h"
 #include "googleurl/src/gurl.h"
 #include "media/base/seekable_buffer.h"
 #include "net/base/file_stream.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoader.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoaderClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "webkit/glue/media/web_data_source.h"
 #include "webkit/glue/webmediaplayer_impl.h"
 
 namespace webkit_glue {
 
 const int64 kPositionNotSpecified = -1;
 
 const char kHttpScheme[] = "http";
 const char kHttpsScheme[] = "https";
 const char kDataScheme[] = "data";
 
+class BufferedDataSource;

[acolwell GONE FROM CHROMIUM, 2011/03/25 23:08:14]

No longer necessary.

[vrk (LEFT CHROMIUM), 2011/03/29 00:53:00]

Done.

 // This class works inside demuxer thread and render thread. It contains a
 // WebURLLoader and does the actual resource loading. This object does
 // buffering internally, it defers the resource loading if buffer is full
 // and un-defers the resource loading if it is under buffered.
 class BufferedResourceLoader :
     public base::RefCountedThreadSafe<BufferedResourceLoader>,
     public WebKit::WebURLLoaderClient {
  public:
+  enum DeferStrategy {

[acolwell GONE FROM CHROMIUM, 2011/03/25 23:08:14]

Brief comments about each of these.

[vrk (LEFT CHROMIUM), 2011/03/29 00:53:00]

Done.

I also changed the naming style to match the style of the State enum in
pipeline_impl.h, but the convention is different in pipeline_status.h? Style
guide is a little ambiguous; I could read it saying we only use MACRO_STYLE or
either is OK based on what existing code was doing?

[acolwell GONE FROM CHROMIUM, 2011/03/29 05:52:03]

I think the kXXX style is good here. I think PipelineStatus is MACRO_STYLE
because it looks more like error code macros  in Unix & Windows. I don't know
the history, but that would be my guess.
On 2011/03/29 00:53:00, Victoria Kirst wrote:

+    NeverDefer,
+    ReadThenDefer,
+    ThresholdDefer
+  };
+
   typedef Callback0::Type NetworkEventCallback;
 
   // |url| - URL for the resource to be loaded.
   // |first_byte_position| - First byte to start loading from,
   // |kPositionNotSpecified| for not specified.
   // |last_byte_position| - Last byte to be loaded,
   // |kPositionNotSpecified| for not specified.
   BufferedResourceLoader(const GURL& url,
                          int64 first_byte_position,
                          int64 last_byte_position);
@@ skipping 29 matching lines @@
   //   The read has failed because of an error with the network.
   // - net::ERR_CACHE_MISS
   //   The read was made too far away from the current buffered position.
   virtual void Read(int64 position, int read_size,
                     uint8* buffer, net::CompletionCallback* callback);
 
   // Returns the position of the last byte buffered. Returns
   // |kPositionNotSpecified| if such value is not available.
   virtual int64 GetBufferedPosition();
 
-  // Sets whether deferring data is allowed or disallowed.
-  virtual void SetAllowDefer(bool is_allowed);
-
   // Gets the content length in bytes of the instance after this loader has been
   // started. If this value is |kPositionNotSpecified|, then content length is
   // unknown.
   virtual int64 content_length();
 
   // Gets the original size of the file requested. If this value is
   // |kPositionNotSpecified|, then the size is unknown.
   virtual int64 instance_size();
 
   // Returns true if the response for this loader is a partial response.
@@ skipping 33 matching lines @@
       const char* data, int dataLength);
   virtual void didFinishLoading(
       WebKit::WebURLLoader* loader,
       double finishTime);
   virtual void didFail(
       WebKit::WebURLLoader* loader,
       const WebKit::WebURLError&);
 
   bool HasSingleOrigin() const;
 
+  void SetDeferStrategy(DeferStrategy strategy);
+
+  // Updates deferring behavior based on current buffering scheme.
+  void UpdateDeferBehavior();

[acolwell GONE FROM CHROMIUM, 2011/03/25 23:08:14]

I believe this can become private once the one call in BufferedDataSource gets
moved to SetDeferStrategy().

[vrk (LEFT CHROMIUM), 2011/03/29 00:53:00]

Done.

+
  protected:
   friend class base::RefCountedThreadSafe<BufferedResourceLoader>;
-
   virtual ~BufferedResourceLoader();
 
  private:
+

[acolwell GONE FROM CHROMIUM, 2011/03/25 23:08:14]

Remove blank line

[vrk (LEFT CHROMIUM), 2011/03/29 00:53:00]

Done.

   friend class BufferedResourceLoaderTest;
 
-  // Defer the resource loading if the buffer is full.
-  void EnableDeferIfNeeded();
+  // Toggles whether the resource loading is deferred or not.
+  // Returns true if a network event was fired.
+  bool ToggleDeferring();
 
-  // Disable defer loading if we are under-buffered.
-  void DisableDeferIfNeeded();
+  // Returns true if we should defer resource loading, based
+  // on current buffering scheme.
+  bool ShouldEnableDefer();
+
+  // Returns true if we should enable resource loading, based
+  // on current buffering scheme.
+  bool ShouldDisableDefer();
 
   // Returns true if the current read request can be fulfilled by what is in
   // the buffer.
   bool CanFulfillRead();
 
   // Returns true if the current read request will be fulfilled in the future.
   bool WillFulfillRead();
 
   // Method that does the actual read and calls the |read_callback_|, assuming
   // the request range is in |buffer_|.
@@ skipping 22 matching lines @@
   void NotifyNetworkEvent();
 
   bool HasPendingRead() { return read_callback_.get() != NULL; }
 
   // A sliding window of buffer.
   scoped_ptr<media::SeekableBuffer> buffer_;
 
   // True if resource loading was deferred.
   bool deferred_;
 
-  // True if resource loader is allowed to defer, false otherwise.
-  bool defer_allowed_;
+  DeferStrategy defer_strategy_;
 
   // True if resource loading has completed.
   bool completed_;
 
   // True if a range request was made.
   bool range_requested_;
 
   // True if response data received is a partial range.
   bool partial_response_;
 
@@ skipping 28 matching lines @@
 
   // Used to ensure mocks for unittests are used instead of reset in Start().
   bool keep_test_loader_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoader);
 };
 
 }  // namespace webkit_glue
 
 #endif  // WEBKIT_GLUE_MEDIA_BUFFERED_RESOURCE_LOADER_H_