Return AUTHENTICATION_FAILED error if Drive operation has failed and user is not signed in

chrome/browser/sync_file_system/drive_file_sync_service.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/sync_file_system/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 644 matching lines @@
   sync_client_->GetDriveDirectoryForSyncRoot(
       base::Bind(&DriveFileSyncService::DidGetSyncRootDirectory,
                   AsWeakPtr(), base::Passed(&token), callback));
 }
 
 void DriveFileSyncService::DidGetSyncRootDirectory(
     scoped_ptr<TaskToken> token,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id) {
-  fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
+  fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   if (error != google_apis::HTTP_SUCCESS &&
       error != google_apis::HTTP_CREATED) {
     NotifyTaskDone(status, token.Pass());
     callback.Run(status);
     return;
   }
 
   metadata_store_->SetSyncRootDirectory(resource_id);
   NotifyTaskDone(fileapi::SYNC_STATUS_OK, token.Pass());
   callback.Run(status);
@@ skipping 28 matching lines @@
 }
 
 void DriveFileSyncService::DidGetDirectoryForOrigin(
     scoped_ptr<TaskToken> token,
     const GURL& origin,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id) {
   if (error != google_apis::HTTP_SUCCESS &&
       error != google_apis::HTTP_CREATED) {
-    fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
+    fileapi::SyncStatusCode status =
+        GDataErrorCodeToSyncStatusCodeWrapper(error);
     NotifyTaskDone(status, token.Pass());
     callback.Run(status);
     return;
   }
 
   metadata_store_->AddBatchSyncOrigin(origin, resource_id);
 
   NotifyTaskDone(fileapi::SYNC_STATUS_OK, token.Pass());
   callback.Run(fileapi::SYNC_STATUS_OK);
 
   StartBatchSyncForOrigin(origin, resource_id);
 }
 
 void DriveFileSyncService::DidGetLargestChangeStampForBatchSync(
     scoped_ptr<TaskToken> token,
     const GURL& origin,
     const std::string& resource_id,
     google_apis::GDataErrorCode error,
     int64 largest_changestamp) {
   if (error != google_apis::HTTP_SUCCESS) {
     pending_batch_sync_origins_.insert(origin);
     // TODO(tzik): Refine this error code.
-    NotifyTaskDone(GDataErrorCodeToSyncStatusCode(error), token.Pass());
+    NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
     return;
   }
 
   DCHECK(token);
   token->UpdateTask(FROM_HERE, TASK_TYPE_DRIVE, "Retrieving remote files");
   sync_client_->ListFiles(
       resource_id,
       base::Bind(
           &DriveFileSyncService::DidGetDirectoryContentForBatchSync,
           AsWeakPtr(), base::Passed(&token), origin, largest_changestamp));
 }
 
 void DriveFileSyncService::DidGetDirectoryContentForBatchSync(
     scoped_ptr<TaskToken> token,
     const GURL& origin,
     int64 largest_changestamp,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::DocumentFeed> feed) {
   if (error != google_apis::HTTP_SUCCESS) {
     pending_batch_sync_origins_.insert(origin);
     // TODO(tzik): Refine this error code.
-    NotifyTaskDone(GDataErrorCodeToSyncStatusCode(error), token.Pass());
+    NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
     return;
   }
 
   typedef ScopedVector<google_apis::DocumentEntry>::const_iterator iterator;
   for (iterator itr = feed->entries().begin();
        itr != feed->entries().end(); ++itr) {
     AppendNewRemoteChange(origin, *itr, largest_changestamp,
                           REMOTE_SYNC_TYPE_BATCH);
   }
 
@@ skipping 20 matching lines @@
 
 void DriveFileSyncService::DidGetRemoteFileMetadata(
     const fileapi::SyncFileMetadataCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::DocumentEntry> entry) {
   fileapi::SyncFileType file_type = fileapi::SYNC_FILE_TYPE_UNKNOWN;
   if (entry->is_file())
     file_type = fileapi::SYNC_FILE_TYPE_FILE;
   else if (entry->is_folder())
     file_type = fileapi::SYNC_FILE_TYPE_DIRECTORY;
-  callback.Run(GDataErrorCodeToSyncStatusCode(error),
+  callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error),
                fileapi::SyncFileMetadata(file_type,
                                          entry->file_size(),
                                          entry->updated_time()));
 }
 
 DriveFileSyncService::SyncOperationType
 DriveFileSyncService::ResolveSyncOperationType(
     const fileapi::FileChange& local_file_change,
     const fileapi::FileSystemURL& url) {
   // TODO(nhiroki): check metadata.conflicted() flag before checking the pending
@@ skipping 51 matching lines @@
 }
 
 void DriveFileSyncService::DidApplyLocalChange(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const google_apis::GDataErrorCode error,
     const fileapi::SyncStatusCallback& callback,
     fileapi::SyncStatusCode status) {
   if (status == fileapi::SYNC_STATUS_OK) {
     CancelRemoteChange(url);
-    NotifyTaskDone(GDataErrorCodeToSyncStatusCode(error), token.Pass());
-    callback.Run(GDataErrorCodeToSyncStatusCode(error));
+    NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
+    callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
     return;
   }
   NotifyTaskDone(status, token.Pass());
   callback.Run(status);
 }
 
 void DriveFileSyncService::DidUploadNewFile(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id,
     const std::string& file_md5) {
   if (error == google_apis::HTTP_SUCCESS) {
     DriveMetadata metadata;
     metadata_store_->ReadEntry(url, &metadata);
     metadata.set_resource_id(resource_id);
     metadata.set_md5_checksum(file_md5);
     metadata.set_conflicted(false);
     metadata_store_->UpdateEntry(
         url, metadata,
         base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                    AsWeakPtr(), base::Passed(&token), url, error, callback));
     return;
   }
-  const fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
+  const fileapi::SyncStatusCode status =
+      GDataErrorCodeToSyncStatusCodeWrapper(error);
   NotifyTaskDone(status, token.Pass());
   callback.Run(status);
 }
 
 void DriveFileSyncService::DidUploadExistingFile(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id,
@@ skipping 22 matching lines @@
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       return;
     }
     case google_apis::HTTP_NOT_MODIFIED: {
       DidApplyLocalChange(token.Pass(), url, google_apis::HTTP_SUCCESS,
                           callback, fileapi::SYNC_STATUS_OK);
       return;
     }
     default: {
       const fileapi::SyncStatusCode status =
-          GDataErrorCodeToSyncStatusCode(error);
+          GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(fileapi::SYNC_STATUS_OK, status);
       DidApplyLocalChange(token.Pass(), url, error, callback, status);
       return;
     }
   }
 }
 
 void DriveFileSyncService::DidDeleteFile(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
@@ skipping 13 matching lines @@
       metadata_store_->ReadEntry(url, &metadata);
       metadata.set_conflicted(true);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       return;
     }
     default: {
       const fileapi::SyncStatusCode status =
-          GDataErrorCodeToSyncStatusCode(error);
+          GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(fileapi::SYNC_STATUS_OK, status);
       DidApplyLocalChange(token.Pass(), url, error, callback, status);
       return;
     }
   }
 }
 
 void DriveFileSyncService::DidPrepareForProcessRemoteChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     fileapi::SyncStatusCode status,
@@ skipping 149 matching lines @@
 void DriveFileSyncService::DidDownloadFile(
     scoped_ptr<ProcessRemoteChangeParam> param,
     google_apis::GDataErrorCode error,
     const std::string& md5_checksum) {
   if (error == google_apis::HTTP_NOT_MODIFIED) {
     param->operation_type = fileapi::SYNC_OPERATION_NONE;
     CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
     return;
   }
 
-  fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
+  fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
   param->md5_checksum = md5_checksum;
   const fileapi::FileChange& change = param->remote_change.change;
   const FilePath& temporary_file_path = param->temporary_file_path;
   const fileapi::FileSystemURL& url = param->remote_change.url;
   param->processor->ApplyRemoteChange(
@@ skipping 160 matching lines @@
   if (found_url == url_to_change_.end())
     return false;
   const PathToChange& path_to_change = found_url->second;
   PathToChange::const_iterator found_path = path_to_change.find(url.path());
   if (found_path == path_to_change.end())
     return false;
   *change = found_path->second;
   return true;
 }
 
+fileapi::SyncStatusCode
+DriveFileSyncService::GDataErrorCodeToSyncStatusCodeWrapper(
+    google_apis::GDataErrorCode error) const {
+  fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
+  if (status != fileapi::SYNC_STATUS_OK && !sync_client_->IsAuthenticated())
+    return fileapi::SYNC_STATUS_AUTHENTICATION_FAILED;
+  return status;
+}
+
 }  // namespace sync_file_system