Move response_container_ into the URLFetcher::Core.

chrome/common/net/url_fetcher.cc

 // Copyright (c) 2011 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 "chrome/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 174 matching lines @@
   base::TimeTicks GetBackoffReleaseTime();
 
   void CompleteAddingUploadDataChunk(const std::string& data,
                                      bool is_last_chunk);
 
   // Adds a block of data to be uploaded in a POST body. This can only be
   // called after Start().
   void AppendChunkToUpload(const std::string& data, bool is_last_chunk);
 
   // Store the response bytes in |buffer_| in the container indicated by
-  // |fetcher_->response_destination_|. Return true if the write has been
+  // |response_destination_|. Return true if the write has been
   // done, and another read can overwrite |buffer_|.  If this function
   // returns false, it will post a task that will read more bytes once the
   // write is complete.
   bool WriteBuffer(int num_bytes);
 
   // Read response bytes from the request.
   void ReadResponse();
 
   URLFetcher* fetcher_;              // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
@@ skipping 52 matching lines @@
   bool was_cancelled_;
 
   // Since GetBackoffReleaseTime() can only be called on the IO thread, we cache
   // its value to be used by OnCompletedURLRequest on the creating thread.
   base::TimeTicks backoff_release_time_;
 
   // If writing results to a file, |temp_file_writer_| will manage creation,
   // writing, and destruction of that file.
   scoped_ptr<TempFileWriter> temp_file_writer_;
 
+  // Where should responses be saved?
+  ResponseDestinationType response_destination_;
+
   static base::LazyInstance<Registry> g_registry;
 
   friend class URLFetcher;
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 URLFetcher::Core::Registry::Registry() {}
 URLFetcher::Core::Registry::~Registry() {}
 
 void URLFetcher::Core::Registry::AddURLFetcherCore(Core* core) {
@@ skipping 181 matching lines @@
 // TODO(skerner): This default implementation will be removed, and the
 // method made pure virtual, once all users of URLFetcher are updated
 // to not expect response data as a string argument.  Once this is removed,
 // the method URLFetcher::GetResponseStringRef() can be removed as well.
 // crbug.com/83592 tracks this.
 void URLFetcher::Delegate::OnURLFetchComplete(const URLFetcher* source) {
   // A delegate that did not override this method is using the old
   // parameter list to OnURLFetchComplete(). If a user asked to save
   // the response to a file, they must use the new parameter list,
   // in which case we can not get here.
-  CHECK(source->response_destination_ == STRING);
-
   // To avoid updating all callers, thunk to the old prototype for now.
   OnURLFetchComplete(source,
                      source->url(),
                      source->status(),
                      source->response_code(),
                      source->cookies(),
                      source->GetResponseStringRef());
 }
 
 // static
 bool URLFetcher::g_interception_enabled = false;
 
 URLFetcher::URLFetcher(const GURL& url,
                        RequestType request_type,
                        Delegate* d)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
       core_(new Core(this, url, request_type, d))),
       automatically_retry_on_5xx_(true),
-      max_retries_(0),
-      response_destination_(STRING) {
+      max_retries_(0) {
 }
 
 URLFetcher::~URLFetcher() {
   core_->Stop();
 }
 
 // static
 URLFetcher* URLFetcher::Create(int id, const GURL& url,
                                RequestType request_type, Delegate* d) {
   return factory_ ? factory_->CreateURLFetcher(id, url, request_type, d) :
                     new URLFetcher(url, request_type, d);
 }
 
 URLFetcher::Core::Core(URLFetcher* fetcher,
                        const GURL& original_url,
                        RequestType request_type,
                        URLFetcher::Delegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_proxy_(
           base::MessageLoopProxy::CreateForCurrentThread()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(URLFetcher::kInvalidHttpResponseCode),
       buffer_(new net::IOBuffer(kBufferSize)),
       is_chunked_upload_(false),
       num_retries_(0),
-      was_cancelled_(false) {
+      was_cancelled_(false),
+      response_destination_(STRING) {
 }
 
 URLFetcher::Core::~Core() {
   // |request_| should be NULL.  If not, it's unsafe to delete it here since we
   // may not be on the IO thread.
   DCHECK(!request_.get());
 }
 
 void URLFetcher::Core::Start() {
   DCHECK(delegate_loop_proxy_);
   CHECK(request_context_getter_) << "We need an URLRequestContext!";
   io_message_loop_proxy_ = request_context_getter_->GetIOMessageLoopProxy();
   CHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
 
-  switch (fetcher_->response_destination_) {
+  switch (response_destination_) {
     case STRING:
       io_message_loop_proxy_->PostTask(
           FROM_HERE,
           NewRunnableMethod(this, &Core::StartURLRequestWhenAppropriate));
       break;
 
     case TEMP_FILE:
       CHECK(file_message_loop_proxy_.get())
           << "Need to set the file message loop proxy.";
       temp_file_writer_.reset(
@@ skipping 61 matching lines @@
       FROM_HERE,
       NewRunnableMethod(this, &Core::CompleteAddingUploadDataChunk, content,
                         is_last_chunk));
 }
 
 // Return true if the write was done and reading may continue.
 // Return false if the write is pending, and the next read will
 // be done later.
 bool URLFetcher::Core::WriteBuffer(int num_bytes) {
   bool write_complete = false;
-  switch (fetcher_->response_destination_) {
+  switch (response_destination_) {
     case STRING:
       data_.append(buffer_->data(), num_bytes);
       write_complete = true;
       break;
 
     case TEMP_FILE:
       temp_file_writer_->WriteBuffer(num_bytes);
       // WriteBuffer() sends a request the file thread.
       // The write is not done yet.
       write_complete = false;
@@ skipping 278 matching lines @@
   core_->request_context_getter_ = request_context_getter;
 }
 
 void URLFetcher::set_automatically_retry_on_5xx(bool retry) {
   automatically_retry_on_5xx_ = retry;
 }
 
 void URLFetcher::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
   core_->file_message_loop_proxy_ = file_message_loop_proxy;
-  response_destination_ = TEMP_FILE;
+  core_->response_destination_ = TEMP_FILE;
 }
 
 net::HttpResponseHeaders* URLFetcher::response_headers() const {
   return core_->response_headers_;
 }
 
 // TODO(panayiotis): socket_address_ is written in the IO thread,
 // if this is accessed in the UI thread, this could result in a race.
 // Same for response_headers_ above and was_fetched_via_proxy_ below.
 net::HostPortPair URLFetcher::socket_address() const {
@@ skipping 38 matching lines @@
 
   *out_error_code = error_code;
   return true;
 }
 
 void URLFetcher::ReceivedContentWasMalformed() {
   core_->ReceivedContentWasMalformed();
 }
 
 bool URLFetcher::GetResponseAsString(std::string* out_response_string) const {
-  if (response_destination_ != STRING)
+  if (core_->response_destination_ != STRING)
     return false;
 
   *out_response_string = core_->data_;
   return true;
 }
 
 const std::string& URLFetcher::GetResponseStringRef() const {
-  CHECK(response_destination_ == STRING);
+  CHECK(core_->response_destination_ == STRING);
   return core_->data_;
 }
 
+void URLFetcher::SetResponseDestinationForTesting(
+    ResponseDestinationType value) {
+  core_->response_destination_ = value;
+}
+
+URLFetcher::ResponseDestinationType
+URLFetcher::GetResponseDestinationForTesting() const {
+  return core_->response_destination_;
+}
+
 bool URLFetcher::GetResponseAsFilePath(bool take_ownership,
                                        FilePath* out_response_path) const {
-  if (response_destination_ != TEMP_FILE || !core_->temp_file_writer_.get())
+  if (core_->response_destination_ != TEMP_FILE ||
+      !core_->temp_file_writer_.get())
     return false;
 
   *out_response_path = core_->temp_file_writer_->temp_file();
 
   if (take_ownership)
     core_->temp_file_writer_->DisownTempFile();
 
   return true;
 }
 
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }