[SyncFS] SyncWorker cache refresh token status

chrome/browser/sync_file_system/drive_backend/sync_worker.cc

 // Copyright 2014 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_backend/sync_worker.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 84 matching lines @@
       service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
       should_check_conflict_(true),
       should_check_remote_change_(true),
       listing_remote_changes_(false),
       sync_enabled_(false),
       default_conflict_resolution_policy_(
           CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN),
       network_available_(false),
       extension_service_(extension_service),
       context_(sync_engine_context.Pass()),
+      has_refresh_token_(false),
       weak_ptr_factory_(this) {}
 
 SyncWorker::~SyncWorker() {}
 
 void SyncWorker::Initialize() {
   DCHECK(!task_manager_);
 
   task_manager_.reset(new SyncTaskManager(
       weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */));
   task_manager_->Initialize(SYNC_STATUS_OK);
 
   PostInitializeTask();
 
   net::NetworkChangeNotifier::ConnectionType type =
       net::NetworkChangeNotifier::GetConnectionType();
   network_available_ =
       type != net::NetworkChangeNotifier::CONNECTION_NONE;
 }
 
 void SyncWorker::RegisterOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  if (!GetMetadataDatabase() && GetDriveService()->HasRefreshToken())
+  if (!GetMetadataDatabase() && has_refresh_token_)
     PostInitializeTask();
 
   scoped_ptr<RegisterAppTask> task(
       new RegisterAppTask(context_.get(), origin.host()));
   if (task->CanFinishImmediately()) {
     context_->GetUITaskRunner()->PostTask(
         FROM_HERE, base::Bind(callback, SYNC_STATUS_OK));
     return;
   }
 
@@ skipping 201 matching lines @@
 
 void SyncWorker::OnNotificationReceived() {
   if (service_state_ == REMOTE_SERVICE_TEMPORARY_UNAVAILABLE)
     UpdateServiceState(REMOTE_SERVICE_OK, "Got push notification for Drive.");
 
   should_check_remote_change_ = true;
   MaybeScheduleNextTask();
 }
 
 void SyncWorker::OnReadyToSendRequests(const std::string& account_id) {
+  has_refresh_token_ = true;
   if (service_state_ == REMOTE_SERVICE_OK)
     return;
   UpdateServiceState(REMOTE_SERVICE_OK, "Authenticated");
 
   if (!GetMetadataDatabase() && !account_id.empty()) {
     GetDriveService()->Initialize(account_id);
     PostInitializeTask();
     return;
   }
 
   should_check_remote_change_ = true;
   MaybeScheduleNextTask();
 }
 
 void SyncWorker::OnRefreshTokenInvalid() {
+  has_refresh_token_ = false;
+
   UpdateServiceState(
       REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
       "Found invalid refresh token.");
 }
 
 void SyncWorker::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   bool new_network_availability =
       type != net::NetworkChangeNotifier::CONNECTION_NONE;
 
@@ skipping 61 matching lines @@
       scoped_ptr<SyncTask>(initializer),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&SyncWorker::DidInitialize,
                  weak_ptr_factory_.GetWeakPtr(),
                  initializer));
 }
 
 void SyncWorker::DidInitialize(SyncEngineInitializer* initializer,
                                SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    if (GetDriveService()->HasRefreshToken()) {
+    if (has_refresh_token_) {
       UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE,
                          "Could not initialize remote service");
     } else {
       UpdateServiceState(REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
                          "Authentication required.");
     }
     return;
   }
 
   scoped_ptr<MetadataDatabase> metadata_database =
@@ skipping 208 matching lines @@
     case SYNC_STATUS_ACCESS_FORBIDDEN:
       UpdateServiceState(REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
                          "Access forbidden");
       break;
 
     // Errors which could make the service temporarily unavailable.
     case SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE:
     case SYNC_STATUS_NETWORK_ERROR:
     case SYNC_STATUS_ABORT:
     case SYNC_STATUS_FAILED:
-      if (GetDriveService()->HasRefreshToken()) {
+      if (has_refresh_token_) {
         UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE,
                            "Network or temporary service error.");
       } else {
         UpdateServiceState(REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
                            "Authentication required");
       }
       break;
 
     // Errors which would require manual user intervention to resolve.
     case SYNC_DATABASE_ERROR_CORRUPTION:
@@ skipping 21 matching lines @@
             "Service state changed: %d->%d: %s",
             old_state, GetCurrentState(), description.c_str());
 
   FOR_EACH_OBSERVER(
       Observer, observers_,
       UpdateServiceState(GetCurrentState(), description));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system