Rename WebKit namespace to blink (part 3)

content/renderer/media/buffered_resource_loader.h

 // Copyright 2013 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 CONTENT_RENDERER_MEDIA_BUFFERED_RESOURCE_LOADER_H_
 #define CONTENT_RENDERER_MEDIA_BUFFERED_RESOURCE_LOADER_H_
 
 #include <string>
 
 #include "base/callback.h"
@@ skipping 18 matching lines @@
 const int64 kPositionNotSpecified = -1;
 
 const char kHttpScheme[] = "http";
 const char kHttpsScheme[] = "https";
 
 // BufferedResourceLoader is single threaded and must be accessed on the
 // render thread. It wraps a WebURLLoader and does in-memory buffering,
 // pausing resource loading when the in-memory buffer is full and resuming
 // resource loading when there is available capacity.
 class CONTENT_EXPORT BufferedResourceLoader
-    : NON_EXPORTED_BASE(public WebKit::WebURLLoaderClient) {
+    : NON_EXPORTED_BASE(public blink::WebURLLoaderClient) {
  public:
   // kNeverDefer - Aggresively buffer; never defer loading while paused.
   // kReadThenDefer - Request only enough data to fulfill read requests.
   // kCapacityDefer - Try to keep amount of buffered data at capacity.
   enum DeferStrategy {
     kNeverDefer,
     kReadThenDefer,
     kCapacityDefer,
   };
 
@@ skipping 49 matching lines @@
   // Start the resource loading with the specified URL and range.
   //
   // |loading_cb| is executed when the loading state has changed.
   // |progress_cb| is executed when additional data has arrived.
   typedef base::Callback<void(Status)> StartCB;
   typedef base::Callback<void(LoadingState)> LoadingStateChangedCB;
   typedef base::Callback<void(int64)> ProgressCB;
   void Start(const StartCB& start_cb,
              const LoadingStateChangedCB& loading_cb,
              const ProgressCB& progress_cb,
-             WebKit::WebFrame* frame);
+             blink::WebFrame* frame);
 
   // Stops everything associated with this loader, including active URL loads
   // and pending callbacks.
   //
   // It is safe to delete a BufferedResourceLoader after calling Stop().
   void Stop();
 
   // Copies |read_size| bytes from |position| into |buffer|, executing |read_cb|
   // when the operation has completed.
   //
@@ skipping 11 matching lines @@
   // unknown.
   int64 content_length();
 
   // Gets the original size of the file requested. If this value is
   // |kPositionNotSpecified|, then the size is unknown.
   int64 instance_size();
 
   // Returns true if the server supports byte range requests.
   bool range_supported();
 
-  // WebKit::WebURLLoaderClient implementation.
+  // blink::WebURLLoaderClient implementation.
   virtual void willSendRequest(
-      WebKit::WebURLLoader* loader,
-      WebKit::WebURLRequest& newRequest,
-      const WebKit::WebURLResponse& redirectResponse);
+      blink::WebURLLoader* loader,
+      blink::WebURLRequest& newRequest,
+      const blink::WebURLResponse& redirectResponse);
   virtual void didSendData(
-      WebKit::WebURLLoader* loader,
+      blink::WebURLLoader* loader,
       unsigned long long bytesSent,
       unsigned long long totalBytesToBeSent);
   virtual void didReceiveResponse(
-      WebKit::WebURLLoader* loader,
-      const WebKit::WebURLResponse& response);
+      blink::WebURLLoader* loader,
+      const blink::WebURLResponse& response);
   virtual void didDownloadData(
-      WebKit::WebURLLoader* loader,
+      blink::WebURLLoader* loader,
       int data_length,
       int encoded_data_length);
   virtual void didReceiveData(
-      WebKit::WebURLLoader* loader,
+      blink::WebURLLoader* loader,
       const char* data,
       int data_length,
       int encoded_data_length);
   virtual void didReceiveCachedMetadata(
-      WebKit::WebURLLoader* loader,
+      blink::WebURLLoader* loader,
       const char* data, int dataLength);
   virtual void didFinishLoading(
-      WebKit::WebURLLoader* loader,
+      blink::WebURLLoader* loader,
       double finishTime);
   virtual void didFail(
-      WebKit::WebURLLoader* loader,
-      const WebKit::WebURLError&);
+      blink::WebURLLoader* loader,
+      const blink::WebURLError&);
 
   // Returns true if the media resource has a single origin, false otherwise.
   // Only valid to call after Start() has completed.
   bool HasSingleOrigin() const;
 
   // Returns true if the media resource passed a CORS access control check.
   // Only valid to call after Start() has completed.
   bool DidPassCORSAccessCheck() const;
 
   // Sets the defer strategy to the given value unless it seems unwise.
@@ skipping 47 matching lines @@
   bool CanFulfillRead() const;
 
   // Returns true if the current read request will be fulfilled in the future.
   bool WillFulfillRead() const;
 
   // Method that does the actual read and calls the |read_cb_|, assuming the
   // request range is in |buffer_|.
   void ReadInternal();
 
   // If we have made a range request, verify the response from the server.
-  bool VerifyPartialResponse(const WebKit::WebURLResponse& response);
+  bool VerifyPartialResponse(const blink::WebURLResponse& response);
 
   // Returns the value for a range request header using parameters
   // |first_byte_position| and |last_byte_position|. Negative numbers other
   // than |kPositionNotSpecified| are not allowed for |first_byte_position| and
   // |last_byte_position|. |first_byte_position| should always be less than or
   // equal to |last_byte_position| if they are both not |kPositionNotSpecified|.
   // Empty string is returned on invalid parameters.
   std::string GenerateHeaders(int64 first_byte_position,
                               int64 last_byte_position);
 
@@ skipping 60 matching lines @@
   int64 read_position_;
   int read_size_;
   uint8* read_buffer_;
 
   // Offsets of the requested first byte and last byte in |buffer_|. They are
   // written by Read().
   int first_offset_;
   int last_offset_;
 
   // Injected WebURLLoader instance for testing purposes.
-  scoped_ptr<WebKit::WebURLLoader> test_loader_;
+  scoped_ptr<blink::WebURLLoader> test_loader_;
 
   // Bitrate of the media. Set to 0 if unknown.
   int bitrate_;
 
   // Playback rate of the media.
   float playback_rate_;
 
   scoped_refptr<media::MediaLog> media_log_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoader);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_BUFFERED_RESOURCE_LOADER_H_