google_apis: Implement google_apis::ResponseWriter

net/url_request/url_fetcher_core.cc

 // 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.
 
 #include "net/url_request/url_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 13 matching lines @@
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace {
 
 const int kBufferSize = 4096;
 const int kUploadProgressTimerInterval = 100;
 bool g_interception_enabled = false;
 bool g_ignore_certificate_requests = false;
 
+void EmptyCompletionCallback(int result) {}
+
 }  // namespace
 
 namespace net {
 
 // URLFetcherCore::Registry ---------------------------------------------------
 
 URLFetcherCore::Registry::Registry() {}
 URLFetcherCore::Registry::~Registry() {}
 
 void URLFetcherCore::Registry::AddURLFetcherCore(URLFetcherCore* core) {
@@ skipping 374 matching lines @@
   if (throttler_manager) {
     url_throttler_entry_ = throttler_manager->RegisterRequestUrl(url_);
   }
 
   do {
     if (!request_->status().is_success() || bytes_read <= 0)
       break;
 
     current_response_bytes_ += bytes_read;
     InformDelegateDownloadProgress();
-    InformDelegateDownloadDataIfNecessary(bytes_read);
 
     const int result =
         WriteBuffer(new DrainableIOBuffer(buffer_.get(), bytes_read));
     if (result < 0) {
       // Write failed or waiting for write completion.
       return;
     }
   } while (request_->Read(buffer_.get(), kBufferSize, &bytes_read));
 
   const URLRequestStatus status = request_->status();
@@ skipping 204 matching lines @@
 
   // Release the reference to the request context. There could be multiple
   // references to URLFetcher::Core at this point so it may take a while to
   // delete the object, but we cannot delay the destruction of the request
   // context.
   request_context_getter_ = NULL;
   first_party_for_cookies_ = GURL();
   url_request_data_key_ = NULL;
   url_request_create_data_callback_.Reset();
   was_cancelled_ = true;
-  response_writer_.reset();
 }
 
 void URLFetcherCore::OnCompletedURLRequest(
     base::TimeDelta backoff_delay) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
     backoff_delay_ = backoff_delay;
     InformDelegateFetchIsComplete();
@@ skipping 130 matching lines @@
                                 is_last_chunk);
 }
 
 int URLFetcherCore::WriteBuffer(scoped_refptr<DrainableIOBuffer> data) {
   while (data->BytesRemaining() > 0) {
     const int result = response_writer_->Write(
         data.get(),
         data->BytesRemaining(),
         base::Bind(&URLFetcherCore::DidWriteBuffer, this, data));
     if (result < 0) {
-      if (result != ERR_IO_PENDING) {
-        CancelURLRequest(result);
-        delegate_task_runner_->PostTask(
-            FROM_HERE,
-            base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, this));
-      }
+      if (result != ERR_IO_PENDING)
+        DidWriteBuffer(data, result);
       return result;
     }
     data->DidConsume(result);
   }
   return OK;
 }
 
 void URLFetcherCore::DidWriteBuffer(scoped_refptr<DrainableIOBuffer> data,
                                     int result) {
   if (result < 0) {  // Handle errors.
     CancelURLRequest(result);
+    response_writer_->Finish(base::Bind(&EmptyCompletionCallback));
     delegate_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, this));
     return;
   }
 
   // Continue writing.
   data->DidConsume(result);
   if (WriteBuffer(data) < 0)
     return;
@@ skipping 54 matching lines @@
           this, current_response_bytes_, total_response_bytes_));
 }
 
 void URLFetcherCore::InformDelegateDownloadProgressInDelegateThread(
     int64 current, int64 total) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadProgress(fetcher_, current, total);
 }
 
-void URLFetcherCore::InformDelegateDownloadDataIfNecessary(int bytes_read) {
-  DCHECK(network_task_runner_->BelongsToCurrentThread());
-  if (delegate_ && delegate_->ShouldSendDownloadData()) {
-    scoped_ptr<std::string> download_data(
-        new std::string(buffer_->data(), bytes_read));
-    delegate_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &URLFetcherCore::InformDelegateDownloadDataInDelegateThread,
-            this, base::Passed(&download_data)));
-  }
-}
-
-void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
-    scoped_ptr<std::string> download_data) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
-  if (delegate_)
-    delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
-}
-
 }  // namespace net