Reduce the amount of included header files. Vast change like in "Oh God! This...

net/url_request/url_request.h

 // Copyright (c) 2006-2008 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_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
-#include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_states.h"
-#include "net/base/ssl_info.h"
-#include "net/base/upload_data.h"
-#include "net/base/x509_certificate.h"
 #include "net/http/http_response_info.h"
-#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 
 namespace net {
+
 class IOBuffer;
+class UploadData;
+class X509Certificate;
+
 }
+
+class URLRequestContext;
 class URLRequestJob;
 
 // This stores the values of the Set-Cookie headers received during the request.
 // Each item in the vector corresponds to a Set-Cookie: line received,
 // excluding the "Set-Cookie:" part.
 typedef std::vector<std::string> ResponseCookies;
 
 //-----------------------------------------------------------------------------
 // A class  representing the asynchronous load of a data stream from an URL.
 //
@@ skipping 159 matching lines @@
   static bool IsHandledURL(const GURL& url);
 
   // The original url is the url used to initialize the request, and it may
   // differ from the url if the request was redirected.
   const GURL& original_url() const { return original_url_; }
   const GURL& url() const { return url_; }
 
   // The URL that should be consulted for the third-party cookie blocking
   // policy.
   const GURL& policy_url() const { return policy_url_; }
-  void set_policy_url(const GURL& policy_url) {
-    DCHECK(!is_pending_);
-    policy_url_ = policy_url;
-  }
+  void set_policy_url(const GURL& policy_url);
 
   // The request method, as an uppercase string.  "GET" is the default value.
   // The request method may only be changed before Start() is called and
   // should only be assigned an uppercase value.
   const std::string& method() const { return method_; }
-  void set_method(const std::string& method) {
-    DCHECK(!is_pending_);
-    method_ = method;
-  }
+  void set_method(const std::string& method);
 
   // The referrer URL for the request.  This header may actually be suppressed
   // from the underlying network request for security reasons (e.g., a HTTPS
   // URL will not be sent as the referrer for a HTTP request).  The referrer
   // may only be changed before Start() is called.
   const std::string& referrer() const { return referrer_; }
-  void set_referrer(const std::string& referrer) {
-    DCHECK(!is_pending_);
-    referrer_ = referrer;
-  }
+  void set_referrer(const std::string& referrer);
 
   // The delegate of the request.  This value may be changed at any time,
   // and it is permissible for it to be null.
   Delegate* delegate() const { return delegate_; }
   void set_delegate(Delegate* delegate) { delegate_ = delegate; }
 
   // The data comprising the request message body is specified as a sequence of
   // data segments and/or files containing data to upload.  These methods may
   // be called to construct the data sequence to upload, and they may only be
   // called before Start() is called.  For POST requests, the user must call
   // SetRequestHeaderBy{Id,Name} to set the Content-Type of the request to the
   // appropriate value before calling Start().
   //
   // When uploading data, bytes_len must be non-zero.
   // When uploading a file range, length must be non-zero. If length
   // exceeds the end-of-file, the upload is clipped at end-of-file.
   void AppendBytesToUpload(const char* bytes, int bytes_len);
   void AppendFileRangeToUpload(const std::wstring& file_path,
                                uint64 offset, uint64 length);
   void AppendFileToUpload(const std::wstring& file_path) {
     AppendFileRangeToUpload(file_path, 0, kuint64max);
   }
 
   // Set the upload data directly.
-  void set_upload(net::UploadData* upload) { upload_ = upload; }
+  void set_upload(net::UploadData* upload);
 
   // Get the upload data directly.
-  net::UploadData* get_upload() { return upload_.get(); }
+  net::UploadData* get_upload();
 
   // Returns true if the request has a non-empty message body to upload.
-  bool has_upload() const { return upload_ != NULL; }
+  bool has_upload() const;
 
   // Set an extra request header by ID or name.  These methods may only be
   // called before Start() is called.  It is an error to call it later.
   void SetExtraRequestHeaderById(int header_id, const std::string& value,
                                  bool overwrite);
   void SetExtraRequestHeaderByName(const std::string& name,
                                    const std::string& value, bool overwrite);
 
   // Sets all extra request headers, from a \r\n-delimited string.  Any extra
   // request headers set by other methods are overwritten by this method.  This
@@ skipping 32 matching lines @@
   // responses, this may be a time well in the past.
   const base::Time& response_time() const {
     return response_info_.response_time;
   }
 
   // Indicate if this response was fetched from disk cache.
   bool was_cached() const { return response_info_.was_cached; }
 
   // Get all response headers, as a HttpResponseHeaders object.  See comments
   // in HttpResponseHeaders class as to the format of the data.
-  net::HttpResponseHeaders* response_headers() const {
-    return response_info_.headers.get();
-  }
+  net::HttpResponseHeaders* response_headers() const;
 
   // Get the SSL connection info.
   const net::SSLInfo& ssl_info() const {
     return response_info_.ssl_info;
   }
 
   // Returns the cookie values included in the response, if the request is one
   // that can have cookies.  Returns true if the request is a cookie-bearing
   // type, false otherwise.  This method may only be called once the
   // delegate's OnResponseStarted method has been called.
@@ skipping 89 matching lines @@
 #undef HTTP_ATOM
   };
 
   // Returns true if performance profiling should be enabled on the
   // URLRequestJob serving this request.
   bool enable_profiling() const { return enable_profiling_; }
 
   void set_enable_profiling(bool profiling) { enable_profiling_ = profiling; }
 
   // Used to specify the context (cookie store, cache) for this request.
-  URLRequestContext* context() { return context_.get(); }
-  void set_context(URLRequestContext* context) { context_ = context; }
+  URLRequestContext* context();
+  void set_context(URLRequestContext* context);
 
   // Returns the expected content size if available
   int64 GetExpectedContentSize() const;
 
  protected:
   // Allow the URLRequestJob class to control the is_pending() flag.
   void set_is_pending(bool value) { is_pending_ = value; }
 
   // Allow the URLRequestJob class to set our status too
   void set_status(const URLRequestStatus &value) { status_ = value; }
@@ skipping 54 matching lines @@
   // infinite redirects.
   int redirect_limit_;
 
   // Contextual information used for this request (can be NULL).
   scoped_refptr<URLRequestContext> context_;
 
   // Cached value for use after we've orphaned the job handling the
   // first transaction in a request involving redirects.
   uint64 final_upload_progress_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(URLRequest);
+  DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 //-----------------------------------------------------------------------------
 // To help ensure that all requests are cleaned up properly, we keep static
 // counters of live objects.  TODO(darin): Move this leak checking stuff into
 // a common place and generalize it so it can be used everywhere (Bug 566229).
 
 #ifndef NDEBUG
 
 struct URLRequestMetrics {
   int object_count;
   URLRequestMetrics() : object_count(0) {}
-  ~URLRequestMetrics() {
-    DLOG_IF(WARNING, object_count != 0) <<
-      "Leaking " << object_count << " URLRequest object(s)";
-  }
+  ~URLRequestMetrics();
 };
 
 extern URLRequestMetrics url_request_metrics;
 
 #define URLREQUEST_COUNT_CTOR() url_request_metrics.object_count++
 #define URLREQUEST_COUNT_DTOR() url_request_metrics.object_count--
 
 #else  // disable leak checking in release builds...
 
 #define URLREQUEST_COUNT_CTOR()
 #define URLREQUEST_COUNT_DTOR()
 
-#endif
-
+#endif  // #ifndef NDEBUG
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_
-