Move implementation from header to source.

net/url_request/url_request_job.cc

 // 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.
 
 #include "net/url_request/url_request_job.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
@@ skipping 35 matching lines @@
     metrics_.reset(new URLRequestJobMetrics());
     metrics_->start_time_ = TimeTicks::Now();
   }
   g_url_request_job_tracker.AddNewJob(this);
 }
 
 URLRequestJob::~URLRequestJob() {
   g_url_request_job_tracker.RemoveJob(this);
 }
 
+void URLRequestJob::SetUpload(net::UploadData* upload) {
+}
+
+void URLRequestJob::SetExtraRequestHeaders(
+    const net::HttpRequestHeaders& headers) {
+}
+
 void URLRequestJob::Kill() {
   // Make sure the request is notified that we are done.  We assume that the
   // request took care of setting its error status before calling Kill.
   if (request_)
     NotifyCanceled();
 }
 
 void URLRequestJob::DetachRequest() {
   request_ = NULL;
 }
 
-bool URLRequestJob::IsDownload() const {
-  return (load_flags_ & net::LOAD_IS_DOWNLOAD) != 0;
-}
-
 void URLRequestJob::SetupFilter() {
   std::vector<Filter::FilterType> encoding_types;
   if (GetContentEncodings(&encoding_types)) {
     filter_.reset(Filter::Factory(encoding_types, *this));
   }
 }
 
 bool URLRequestJob::IsRedirectResponse(GURL* location,
                                        int* http_status_code) {
   // For non-HTTP jobs, headers will be null.
   net::HttpResponseHeaders* headers = request_->response_headers();
   if (!headers)
     return false;
 
   std::string value;
   if (!headers->IsRedirect(&value))
     return false;
 
   *location = request_->url().Resolve(value);
   *http_status_code = headers->response_code();
   return true;
 }
 
+bool URLRequestJob::IsSafeRedirect(const GURL& location) {
+  return true;
+}
+
+bool URLRequestJob::NeedsAuth() {
+  return false;
+}
+
 void URLRequestJob::GetAuthChallengeInfo(
     scoped_refptr<net::AuthChallengeInfo>* auth_info) {
   // This will only be called if NeedsAuth() returns true, in which
   // case the derived class should implement this!
   NOTREACHED();
 }
 
 void URLRequestJob::SetAuth(const std::wstring& username,
                             const std::wstring& password) {
   // This will only be called if NeedsAuth() returns true, in which
@@ skipping 36 matching lines @@
   deferred_redirect_url_ = GURL();
   deferred_redirect_status_code_ = -1;
 
   FollowRedirect(redirect_url, redirect_status_code);
 }
 
 int64 URLRequestJob::GetByteReadCount() const {
   return filter_input_byte_count_;
 }
 
+bool URLRequestJob::GetMimeType(std::string* mime_type) const {
+  return false;
+}
+
 bool URLRequestJob::GetURL(GURL* gurl) const {
   if (!request_)
     return false;
   *gurl = request_->url();
   return true;
 }
 
 base::Time URLRequestJob::GetRequestTime() const {
   if (!request_)
     return base::Time();
   return request_->request_time();
 };
 
+bool URLRequestJob::IsCachedContent() const {
+  return false;
+}
+
+int URLRequestJob::GetResponseCode() const {
+  return -1;
+}
+
+int URLRequestJob::GetInputStreamBufferSize() const {
+  return kFilterBufSize;
+}
+
 // This function calls ReadData to get stream data. If a filter exists, passes
 // the data to the attached filter. Then returns the output from filter back to
 // the caller.
 bool URLRequestJob::Read(net::IOBuffer* buf, int buf_size, int *bytes_read) {
   bool rv = false;
 
   DCHECK_LT(buf_size, 1000000);  // sanity check
   DCHECK(buf);
   DCHECK(bytes_read);
 
@@ skipping 18 matching lines @@
   }
   if (rv && *bytes_read == 0)
     NotifyDone(URLRequestStatus());
   return rv;
 }
 
 void URLRequestJob::StopCaching() {
   // Nothing to do here.
 }
 
+net::LoadState URLRequestJob::GetLoadState() const {
+  return net::LOAD_STATE_IDLE;
+}
+
+uint64 URLRequestJob::GetUploadProgress() const {
+  return 0;
+}
+
+bool URLRequestJob::GetCharset(std::string* charset) {
+  return false;
+}
+
+void URLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
+}
+
+bool URLRequestJob::GetResponseCookies(std::vector<std::string>* cookies) {
+  return false;
+}
+
+bool URLRequestJob::GetContentEncodings(
+    std::vector<Filter::FilterType>* encoding_types) {
+  return false;
+}
+
+bool URLRequestJob::IsDownload() const {
+  return (load_flags_ & net::LOAD_IS_DOWNLOAD) != 0;
+}
+
+bool URLRequestJob::IsSdchResponse() const {
+  return false;
+}
+
 bool URLRequestJob::ReadRawDataForFilter(int* bytes_read) {
   bool rv = false;
 
   DCHECK(bytes_read);
   DCHECK(filter_.get());
 
   *bytes_read = 0;
 
   // Get more pre-filtered data if needed.
   // TODO(mbelshe): is it possible that the filter needs *MORE* data
@@ skipping 623 matching lines @@
     return;
   }
 
   if (is_compressed_) {
     COMPRESSION_HISTOGRAM("NoProxy.BytesBeforeCompression", compressed_B);
     COMPRESSION_HISTOGRAM("NoProxy.BytesAfterCompression", decompressed_B);
   } else {
     COMPRESSION_HISTOGRAM("NoProxy.ShouldHaveBeenCompressed", decompressed_B);
   }
 }