Change SDCHDictionaryFetcher to use URLRequest instead of URLFetcher.

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 <stdint.h>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/tracked_objects.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
@@ skipping 584 matching lines @@
 }
 
 void URLFetcherCore::StartURLRequestWhenAppropriate() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
   DCHECK(request_context_getter_.get());
 
-  int64 delay = 0LL;
-  if (original_url_throttler_entry_.get() == NULL) {
+  int64 delay = INT64_C(0);
+  if (!original_url_throttler_entry_.get()) {
     URLRequestThrottlerManager* manager =
         request_context_getter_->GetURLRequestContext()->throttler_manager();
     if (manager) {
       original_url_throttler_entry_ =
           manager->RegisterRequestUrl(original_url_);
     }
   }
-  if (original_url_throttler_entry_.get() != NULL) {
+  if (original_url_throttler_entry_.get()) {
     delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
         GetBackoffReleaseTime());
   }
 
-  if (delay == 0) {
+  if (delay == INT64_C(0)) {
     StartURLRequest();
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
         base::TimeDelta::FromMilliseconds(delay));
   }
 }
 
 void URLFetcherCore::CancelURLRequest(int error) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
@@ skipping 35 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateFetchIsComplete() {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchComplete(fetcher_);
 }
 
 void URLFetcherCore::NotifyMalformedContent() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-  if (url_throttler_entry_.get() != NULL) {
+  if (url_throttler_entry_.get()) {
     int status_code = response_code_;
     if (status_code == URLFetcher::RESPONSE_CODE_INVALID) {
       // The status code will generally be known by the time clients
       // call the |ReceivedContentWasMalformed()| function (which ends up
       // calling the current function) but if it's not, we need to assume
       // the response was successful so that the total failure count
       // used to calculate exponential back-off goes up.
       status_code = 200;
     }
     url_throttler_entry_->ReceivedContentWasMalformed(status_code);
@@ skipping 69 matching lines @@
 
 void URLFetcherCore::ReleaseRequest() {
   upload_progress_checker_timer_.reset();
   request_.reset();
   g_registry.Get().RemoveURLFetcherCore(this);
 }
 
 base::TimeTicks URLFetcherCore::GetBackoffReleaseTime() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  if (original_url_throttler_entry_.get()) {
-    base::TimeTicks original_url_backoff =
-        original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
-    base::TimeTicks destination_url_backoff;
-    if (url_throttler_entry_.get() != NULL &&
-        original_url_throttler_entry_.get() != url_throttler_entry_.get()) {
-      destination_url_backoff =
-          url_throttler_entry_->GetExponentialBackoffReleaseTime();
-    }
+  if (!original_url_throttler_entry_.get())
+    return base::TimeTicks();
 
-    return original_url_backoff > destination_url_backoff ?
-        original_url_backoff : destination_url_backoff;
-  } else {
-    return base::TimeTicks();
+  base::TimeTicks original_url_backoff =
+      original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
+  base::TimeTicks destination_url_backoff;
+  if (url_throttler_entry_.get() &&
+      original_url_throttler_entry_.get() != url_throttler_entry_.get()) {
+    destination_url_backoff =
+        url_throttler_entry_->GetExponentialBackoffReleaseTime();
   }
+
+  return original_url_backoff > destination_url_backoff ?
+      original_url_backoff : destination_url_backoff;
 }
 
 void URLFetcherCore::CompleteAddingUploadDataChunk(
     const std::string& content, bool is_last_chunk) {
   if (was_cancelled_) {
     // Since CompleteAddingUploadDataChunk() is posted as a *delayed* task, it
     // may run after the URLFetcher was already stopped.
     return;
   }
   DCHECK(is_chunked_upload_);
@@ skipping 43 matching lines @@
     ReadResponse();
 }
 
 void URLFetcherCore::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   int bytes_read = 0;
   if (request_->status().is_success() &&
-      (request_type_ != URLFetcher::HEAD))
-    request_->Read(buffer_.get(), kBufferSize, &bytes_read);
+      (request_type_ != URLFetcher::HEAD)) {
+    if (!request_->Read(buffer_.get(), kBufferSize, &bytes_read))
+      bytes_read = -1;  // Match OnReadCompleted() interface contract.
+  }
   OnReadCompleted(request_.get(), bytes_read);
 }
 
 void URLFetcherCore::InformDelegateUploadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   if (request_.get()) {
     int64 current = request_->GetUploadProgress().position();
     if (current_upload_bytes_ != current) {
       current_upload_bytes_ = current;
       int64 total = -1;
@@ skipping 30 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateDownloadProgressInDelegateThread(
     int64 current, int64 total) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadProgress(fetcher_, current, total);
 }
 
 }  // namespace net