Separate BufferedDataSource and BufferedResourceLoader into two files.

net/http/http_util.h

 // Copyright (c) 2006-2009 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 NET_HTTP_HTTP_UTIL_H_
 #define NET_HTTP_HTTP_UTIL_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/ref_counted.h"
 #include "base/string_tokenizer.h"
 #include "googleurl/src/gurl.h"
 #include "net/http/http_byte_range.h"
 
 // This is a macro to support extending this string literal at compile time.
 // Please excuse me polluting your global namespace!
 #define HTTP_LWS " \t"
 
 namespace net {
 
 class HttpAuthController;
 struct HttpRequestInfo;
 class HttpRequestHeaders;
 class HttpStream;
 class UploadDataStream;
 
+const char kHttpScheme[] = "http";
+const char kHttpsScheme[] = "https";
+const char kDataScheme[] = "data";
+const int64 kPositionNotSpecified = -1;
+const int kHttpOK = 200;
+const int kHttpPartialContent = 206;
+
+// Define the number of bytes in a megabyte.
+const size_t kMegabyte = 1024 * 1024;
+
+// Backward capacity of the buffer, by default 2MB.
+const size_t kBackwardCapcity = 2 * kMegabyte;
+
+// Forward capacity of the buffer, by default 10MB.
+const size_t kForwardCapacity = 10 * kMegabyte;
+
+// The threshold of bytes that we should wait until the data arrives in the
+// future instead of restarting a new connection. This number is defined in the
+// number of bytes, we should determine this value from typical connection speed
+// and amount of time for a suitable wait. Now I just make a guess for this
+// number to be 2MB.
+// TODO(hclam): determine a better value for this.
+const int kForwardWaitThreshold = 2 * kMegabyte;
+
+// Defines how long we should wait for more data before we declare a connection
+// timeout and start a new request.
+// TODO(hclam): We should really remove this (crbug.com/64571).
+const int kTimeoutMilliseconds = 5000;
+
+// Defines how many times we should try to read from a buffered resource loader
+// before we declare a read error. After each failure of read from a buffered
+// resource loader, a new one is created to be read.
+const int kReadTrials = 3;
+
+// BufferedDataSource has an intermediate buffer, this value governs the initial
+// size of that buffer. It is set to 32KB because this is a typical read size
+// of FFmpeg.
+const int kInitialReadBufferSize = 32768;

[scherkus (not reviewing), 2010/12/14 18:48:19]

I don't think most of these constants belong here :(

Sorry for not being clearer but I think at a minimum the only stuff that could
go here would be kHttpScheme, kHttpsScheme, kDataScheme and the two
IsXXXProtocol() methods

Everything else is exclusive to buffered data source/resource loader

I'd also try to find some one who works on src/net/ code to take a look

[annacc, 2010/12/14 21:10:17]

OK, I've moved the rest back where they belong, sorry for the confusion.  And
I'm adding ericroman to double check.

[annacc, 2010/12/14 21:30:44]

Scratch the bit about adding ericroman, he's on vacation.  I've added erikwright
instead.

+
 class HttpUtil {
  public:
   // Returns the absolute path of the URL, to be used for the http request.
   // The absolute path starts with a '/' and may contain a query.
   static std::string PathForRequest(const GURL& url);
 
   // Returns the absolute URL, to be used for the http request. This url is
   // made up of the protocol, host, [port], path, [query]. Everything else
   // is stripped (username, password, reference).
   static std::string SpecForRequest(const GURL& url);
@@ skipping 131 matching lines @@
   // |enable_proxy_auth| is true.
   static void BuildRequestHeaders(const HttpRequestInfo* request_info,
                                   const UploadDataStream* upload_data_stream,
                                   const scoped_refptr<HttpAuthController>
                                       auth_controllers[],
                                   bool enable_server_auth,
                                   bool enable_proxy_auth,
                                   bool enable_full_url,
                                   HttpRequestHeaders* request_headers);
 
+  // Returns true if |url| operates on HTTP protocol.
+  static bool IsHttpProtocol(const GURL& url) {
+    return url.SchemeIs(kHttpScheme) || url.SchemeIs(kHttpsScheme);
+  }
+
+  static bool IsDataProtocol(const GURL& url) {
+    return url.SchemeIs(kDataScheme);
+  }
+
   // Used to iterate over the name/value pairs of HTTP headers.  To iterate
   // over the values in a multi-value header, use ValuesIterator.
   // See AssembleRawHeaders for joining line continuations (this iterator
   // does not expect any).
   class HeadersIterator {
    public:
     HeadersIterator(std::string::const_iterator headers_begin,
                     std::string::const_iterator headers_end,
                     const std::string& line_delimiter);
     ~HeadersIterator();
@@ skipping 137 matching lines @@
     // into the original's unquoted_value_ member.
     std::string unquoted_value_;
 
     bool value_is_quoted_;
   };
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_UTIL_H_