gdrive: Get JSON feeds parsing off the UI thread.

chrome/browser/chromeos/gdata/gdata_operations.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 "chrome/browser/chromeos/gdata/gdata_operations.h"
 
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
@@ skipping 256 matching lines @@
   return !get_download_data_callback_.is_null();
 }
 
 void DownloadFileOperation::OnURLFetchDownloadData(
     const URLFetcher* source,
     scoped_ptr<std::string> download_data) {
   if (!get_download_data_callback_.is_null())
     get_download_data_callback_.Run(HTTP_SUCCESS, download_data.Pass());
 }
 
-bool DownloadFileOperation::ProcessURLFetchResults(
-    const URLFetcher* source) {
+void DownloadFileOperation::ProcessURLFetchResults(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
 
   // Take over the ownership of the the downloaded temp file.
   FilePath temp_file;
   if (code == HTTP_SUCCESS &&
       !source->GetResponseAsFilePath(true,  // take_ownership
                                      &temp_file)) {
     code = GDATA_FILE_ERROR;
   }
 
   if (!download_action_callback_.is_null())
     download_action_callback_.Run(code, document_url_, temp_file);
-  return code == HTTP_SUCCESS;
+  OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void DownloadFileOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   if (!download_action_callback_.is_null())
     download_action_callback_.Run(code, document_url_, FilePath());
 }
 
 //=========================== DeleteDocumentOperation ==========================
 
 DeleteDocumentOperation::DeleteDocumentOperation(
@@ skipping 181 matching lines @@
   return URLFetcher::PUT;
 }
 
 std::vector<std::string>
 AuthorizeAppsOperation::GetExtraRequestHeaders() const {
   std::vector<std::string> headers;
   headers.push_back(kIfMatchAllHeader);
   return headers;
 }
 
-bool AuthorizeAppsOperation::ProcessURLFetchResults(
-    const URLFetcher* source) {
+void AuthorizeAppsOperation::ProcessURLFetchResults(const URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
-  return GetDataOperation::ProcessURLFetchResults(source);
+  GetDataOperation::ProcessURLFetchResults(source);
 }
 
 bool AuthorizeAppsOperation::GetContentData(std::string* upload_content_type,
                                             std::string* upload_content) {
   upload_content_type->assign("application/atom+xml");
   XmlWriter xml_writer;
   xml_writer.StartWriting();
   xml_writer.StartElement("entry");
   xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom");
   xml_writer.AddAttribute("xmlns:docs", "http://schemas.google.com/docs/2007");
   xml_writer.WriteElement("docs:authorizedApp", app_id_);
 
   xml_writer.EndElement();  // Ends "entry" element.
   xml_writer.StopWriting();
   upload_content->assign(xml_writer.GetWrittenString());
   DVLOG(1) << "AuthorizeAppOperation data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
-base::Value* AuthorizeAppsOperation::ParseResponse(const std::string& data) {
+void AuthorizeAppsOperation::ParseResponse(
+    GDataErrorCode fetch_error_code,
+    const std::string& data) {
   // Parse entry XML.
   XmlReader xml_reader;
   scoped_ptr<DocumentEntry> entry;
   if (xml_reader.Load(data)) {
     while (xml_reader.Read()) {
       if (xml_reader.NodeName() == DocumentEntry::GetEntryNodeName()) {
         entry.reset(DocumentEntry::CreateFromXml(&xml_reader));
         break;
       }
     }
   }
 
   // From the response, we create a list of the links returned, since those
   // are the only things we are interested in.
   scoped_ptr<base::ListValue> link_list(new ListValue);
   const ScopedVector<Link>& feed_links = entry->links();
   for (ScopedVector<Link>::const_iterator iter = feed_links.begin();
        iter != feed_links.end(); ++iter) {
     if ((*iter)->type() == Link::OPEN_WITH) {
       base::DictionaryValue* link = new DictionaryValue;
       link->SetString(std::string("href"), (*iter)->href().spec());
       link->SetString(std::string("mime_type"), (*iter)->mime_type());
       link->SetString(std::string("title"), (*iter)->title());
       link->SetString(std::string("app_id"), (*iter)->app_id());
       link_list->Append(link);
     }
   }
 
-  return link_list.release();
+  RunCallback(fetch_error_code, link_list.PassAs<base::Value>());
+  const bool success = true;
+  OnProcessURLFetchResultsComplete(success);
 }
 
 GURL AuthorizeAppsOperation::GetURL() const {
   return document_url_;
 }
 
 //======================= AddResourceToDirectoryOperation ======================
 
 AddResourceToDirectoryOperation::AddResourceToDirectoryOperation(
     GDataOperationRegistry* registry,
@@ skipping 92 matching lines @@
           kUploadParamConvertKey,
           kUploadParamConvertValue)) {
 }
 
 InitiateUploadOperation::~InitiateUploadOperation() {}
 
 GURL InitiateUploadOperation::GetURL() const {
   return initiate_upload_url_;
 }
 
-bool InitiateUploadOperation::ProcessURLFetchResults(
+void InitiateUploadOperation::ProcessURLFetchResults(
     const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
 
   std::string upload_location;
   if (code == HTTP_SUCCESS) {
     // Retrieve value of the first "Location" header.
     source->GetResponseHeaders()->EnumerateHeader(NULL,
                                                   kUploadResponseLocation,
                                                   &upload_location);
   }
   VLOG(1) << "Got response for [" << params_.title
           << "]: code=" << code
           << ", location=[" << upload_location << "]";
 
   if (!callback_.is_null())
     callback_.Run(code, GURL(upload_location));
-  return code == HTTP_SUCCESS;
+  OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void InitiateUploadOperation::NotifySuccessToOperationRegistry() {
   NotifySuspend();
 }
 
 void InitiateUploadOperation::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   if (!callback_.is_null())
     callback_.Run(code, GURL());
@@ skipping 66 matching lines @@
       params_(params),
       last_chunk_completed_(false) {
 }
 
 ResumeUploadOperation::~ResumeUploadOperation() {}
 
 GURL ResumeUploadOperation::GetURL() const {
   return params_.upload_location;
 }
 
-bool ResumeUploadOperation::ProcessURLFetchResults(
-    const URLFetcher* source) {
+void ResumeUploadOperation::ProcessURLFetchResults(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   net::HttpResponseHeaders* hdrs = source->GetResponseHeaders();
   int64 start_range_received = -1;
   int64 end_range_received = -1;
   scoped_ptr<DocumentEntry> entry;
 
   if (code == HTTP_RESUME_INCOMPLETE) {
     // Retrieve value of the first "Range" header.
     std::string range_received;
     hdrs->EnumerateHeader(NULL, kUploadResponseRange, &range_received);
@@ skipping 40 matching lines @@
                   entry.Pass());
   }
 
   // For a new file, HTTP_CREATED is returned.
   // For an existing file, HTTP_SUCCESS is returned.
   if ((params_.upload_mode == UPLOAD_NEW_FILE && code == HTTP_CREATED) ||
       (params_.upload_mode == UPLOAD_EXISTING_FILE && code == HTTP_SUCCESS)) {
     last_chunk_completed_ = true;
   }
 
-  return last_chunk_completed_ || code == HTTP_RESUME_INCOMPLETE;
+  OnProcessURLFetchResultsComplete(
+      last_chunk_completed_ || code == HTTP_RESUME_INCOMPLETE);
 }
 
 void ResumeUploadOperation::NotifyStartToOperationRegistry() {
   NotifyResume();
 }
 
 void ResumeUploadOperation::NotifySuccessToOperationRegistry() {
   if (last_chunk_completed_)
     NotifyFinish(GDataOperationRegistry::OPERATION_COMPLETED);
   else
@@ skipping 87 matching lines @@
       photo_url_(photo_url),
       callback_(callback) {
 }
 
 GetContactPhotoOperation::~GetContactPhotoOperation() {}
 
 GURL GetContactPhotoOperation::GetURL() const {
   return photo_url_;
 }
 
-bool GetContactPhotoOperation::ProcessURLFetchResults(
+void GetContactPhotoOperation::ProcessURLFetchResults(
     const net::URLFetcher* source) {
   GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
   scoped_ptr<std::string> data(new std::string);
   source->GetResponseAsString(data.get());
   callback_.Run(code, data.Pass());
-  return code == HTTP_SUCCESS;
+  OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void GetContactPhotoOperation::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   scoped_ptr<std::string> data(new std::string);
   callback_.Run(code, data.Pass());
 }
 
 }  // namespace gdata