Wallpaper manager backend APIs

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/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 193 matching lines @@
     base::PassPlatformFile file_handle,
     const FilePath& file_path) {
   DidCreateFileInternal(file_path, error_code, file_handle);
 }
 
 void URLFetcherCore::FileWriter::DidCreateFileInternal(
     const FilePath& file_path,
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle) {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
-
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveFile();
     core_->delegate_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   file_path_ = file_path;
@@ skipping 394 matching lines @@
 
   switch (response_destination_) {
     case STRING:
       StartURLRequestWhenAppropriate();
       break;
 
     case PERMANENT_FILE:
     case TEMP_FILE:
       DCHECK(file_task_runner_.get())
           << "Need to set the file task runner.";
-
       file_writer_.reset(new FileWriter(this, file_task_runner_));
 
       // If the file is successfully created,
       // URLFetcherCore::StartURLRequestWhenAppropriate() will be called.
       switch (response_destination_) {
         case PERMANENT_FILE:
           file_writer_->CreateFileAtPath(response_destination_file_path_);
           break;
         case TEMP_FILE:
           file_writer_->CreateTempFile();
           break;
         default:
           NOTREACHED();
       }
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void URLFetcherCore::StartURLRequest() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-
   if (was_cancelled_) {
     // Since StartURLRequest() is posted as a *delayed* task, it may
     // run after the URLFetcher was already stopped.
     return;
   }
 
   DCHECK(request_context_getter_);
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
@@ skipping 67 matching lines @@
 
   // If we are writing the response to a file, the only caller
   // of this function should have created it and not written yet.
   DCHECK(!file_writer_.get() || file_writer_->total_bytes_written() == 0);
 
   request_->Start();
 }
 
 void URLFetcherCore::StartURLRequestWhenAppropriate() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-
   if (was_cancelled_)
     return;
 
   DCHECK(request_context_getter_);
 
   int64 delay = 0LL;
   if (original_url_throttler_entry_ == NULL) {
     URLRequestThrottlerManager* manager =
         request_context_getter_->GetURLRequestContext()->throttler_manager();
     if (manager) {
@@ skipping 10 matching lines @@
     StartURLRequest();
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
         base::TimeDelta::FromMilliseconds(delay));
   }
 }
 
 void URLFetcherCore::CancelURLRequest() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-
   if (request_.get()) {
     request_->Cancel();
     ReleaseRequest();
   }
   // 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();
@@ skipping 214 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
     scoped_ptr<std::string> download_data) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
 }
 
 }  // namespace net