Make AssociateWithRenderView() a free function in the 'content' namespace

content/common/net/url_fetcher_core.h

 // Copyright (c) 2012 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_COMMON_NET_URL_FETCHER_CORE_H_
 #define CONTENT_COMMON_NET_URL_FETCHER_CORE_H_
 #pragma once
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/debug/stack_trace.h"
 #include "base/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/platform_file.h"
-#include "base/supports_user_data.h"
 #include "base/timer.h"
 #include "content/public/common/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_request_headers.h"
+#include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 
 namespace base {
 class MessageLoopProxy;
 }  // namespace base
 
 namespace net {
 class HttpResponseHeaders;
 class IOBuffer;
 class URLRequestContextGetter;
 class URLRequestThrottlerEntryInterface;
 }  // namespace net
 
 namespace content {
 
 class URLFetcherDelegate;
 
 class URLFetcherCore
     : public base::RefCountedThreadSafe<URLFetcherCore>,
       public net::URLRequest::Delegate {
  public:
-  // Used by SetURLRequestUserData.  The callback should make a fresh
-  // Data* object every time it's called.
-  typedef base::Callback<base::SupportsUserData::Data*()> CreateDataCallback;
-
   URLFetcherCore(URLFetcher* fetcher,
                  const GURL& original_url,
                  URLFetcher::RequestType request_type,
                  URLFetcherDelegate* d);
 
   // Starts the load.  It's important that this not happen in the constructor
   // because it causes the IO thread to begin AddRef()ing and Release()ing
   // us.  If our caller hasn't had time to fully construct us and take a
   // reference, the IO thread could interrupt things, run a task, Release()
   // us, and destroy us, leaving the caller with an already-destroyed object
@@ skipping 16 matching lines @@
   void AppendChunkToUpload(const std::string& data, bool is_last_chunk);
   // |flags| are flags to apply to the load operation--these should be
   // one or more of the LOAD_* flags defined in net/base/load_flags.h.
   void SetLoadFlags(int load_flags);
   int GetLoadFlags() const;
   void SetReferrer(const std::string& referrer);
   void SetExtraRequestHeaders(const std::string& extra_request_headers);
   void AddExtraRequestHeader(const std::string& header_line);
   void GetExtraRequestHeaders(net::HttpRequestHeaders* headers) const;
   void SetRequestContext(net::URLRequestContextGetter* request_context_getter);
+  // Set the URL that should be consulted for the third-party cookie
+  // blocking policy.
   void SetFirstPartyForCookies(const GURL& first_party_for_cookies);
-  // Whenever a URLRequest object is created, SetUserData() will be
-  // called on it with the given key and the result of the given
-  // callback.
+  // Set the key and data callback that is used when setting the user
+  // data on any URLRequest objects this object creates.
   void SetURLRequestUserData(
-      const void* key, const CreateDataCallback& create_data_callback);
+      const void* key,
+      const net::URLFetcher::CreateDataCallback& create_data_callback);
   void SetAutomaticallyRetryOn5xx(bool retry);
   void SetMaxRetries(int max_retries);
   int GetMaxRetries() const;
   base::TimeDelta GetBackoffDelay() const;
   void SaveResponseToFileAtPath(
       const FilePath& file_path,
       scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy);
   void SaveResponseToTemporaryFile(
       scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy);
   net::HttpResponseHeaders* GetResponseHeaders() const;
@@ skipping 212 matching lines @@
   int response_code_;                // HTTP status code for the request
   std::string data_;                 // Results of the request, when we are
                                      // storing the response as a string.
   scoped_refptr<net::IOBuffer> buffer_;
                                      // Read buffer
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
                                      // Cookie/cache info for the request
   GURL first_party_for_cookies_;     // The first party URL for the request
   // The user data to add to each newly-created URLRequest.
   const void* url_request_data_key_;
-  CreateDataCallback url_request_create_data_callback_;
+  net::URLFetcher::CreateDataCallback url_request_create_data_callback_;
   net::ResponseCookies cookies_;     // Response cookies
   net::HttpRequestHeaders extra_request_headers_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
   bool was_fetched_via_proxy_;
   net::HostPortPair socket_address_;
 
   std::string upload_content_;       // HTTP POST payload
   std::string upload_content_type_;  // MIME type of POST payload
   std::string referrer_;             // HTTP Referer header value
   bool is_chunked_upload_;           // True if using chunked transfer encoding
@@ skipping 60 matching lines @@
   base::debug::StackTrace stack_trace_;
 
   static base::LazyInstance<Registry> g_registry;
 
   DISALLOW_COPY_AND_ASSIGN(URLFetcherCore);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_NET_URL_FETCHER_CORE_H_