Revert 195482 "Make DriveSystemService an observer of DriveNotif..."

trunk/src/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 <string>
 #include <utility>
 
@@ skipping 28 matching lines @@
 using fileapi::FileSystemURL;
 
 namespace sync_file_system {
 
 namespace {
 
 const base::FilePath::CharType kTempDirName[] = FILE_PATH_LITERAL("tmp");
 const base::FilePath::CharType kSyncFileSystemDir[] =
     FILE_PATH_LITERAL("Sync FileSystem");
 
+// Incremental sync polling interval.
+// TODO(calvinlo): Improve polling algorithm dependent on whether push
+// notifications are on or off.
+const int64 kMinimumPollingDelaySeconds = 5;
+const int64 kMaximumPollingDelaySeconds = 10 * 60;  // 10 min
+const int64 kPollingDelaySecondsWithNotification = 4 * 60 * 60;  // 4 hr
+const double kDelayMultiplier = 1.6;
+
 bool CreateTemporaryFile(const base::FilePath& dir_path,
                          base::FilePath* temp_file) {
   return file_util::CreateDirectory(dir_path) &&
       file_util::CreateTemporaryFileInDir(dir_path, temp_file);
 }
 
 void DeleteTemporaryFile(const base::FilePath& file_path) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::FILE, FROM_HERE,
@@ skipping 201 matching lines @@
     return left.changestamp > right.changestamp;
   return false;
 }
 
 DriveFileSyncService::DriveFileSyncService(Profile* profile)
     : profile_(profile),
       last_operation_status_(SYNC_STATUS_OK),
       state_(REMOTE_SERVICE_OK),
       sync_enabled_(true),
       largest_fetched_changestamp_(0),
+      polling_delay_seconds_(kMinimumPollingDelaySeconds),
       may_have_unfetched_changes_(false),
       remote_change_processor_(NULL),
       conflict_resolution_(kDefaultPolicy),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   temporary_file_dir_ =
       profile->GetPath().Append(kSyncFileSystemDir).Append(kTempDirName);
   token_.reset(new TaskToken(AsWeakPtr()));
 
   sync_client_.reset(new DriveFileSyncClient(profile));
   sync_client_->AddObserver(this);
@@ skipping 272 matching lines @@
   if (old_state == GetCurrentState())
     return;
 
   if (!enabled)
     last_operation_status_ = SYNC_STATUS_SYNC_DISABLED;
 
   const char* status_message = enabled ? "Sync is enabled" : "Sync is disabled";
   FOR_EACH_OBSERVER(
       Observer, service_observers_,
       OnRemoteServiceStateUpdated(GetCurrentState(), status_message));
+
+  if (GetCurrentState() == REMOTE_SERVICE_OK) {
+    UpdatePollingDelay(kMinimumPollingDelaySeconds);
+    SchedulePolling();
+  }
 }
 
 SyncStatusCode DriveFileSyncService::SetConflictResolutionPolicy(
     ConflictResolutionPolicy resolution) {
   conflict_resolution_ = resolution;
   return SYNC_STATUS_OK;
 }
 
 ConflictResolutionPolicy
 DriveFileSyncService::GetConflictResolutionPolicy() const {
@@ skipping 50 matching lines @@
 void DriveFileSyncService::OnAuthenticated() {
   if (state_ == REMOTE_SERVICE_OK)
     return;
   DVLOG(1) << "OnAuthenticated";
   state_ = REMOTE_SERVICE_OK;
   if (GetCurrentState() != REMOTE_SERVICE_OK)
     return;
   FOR_EACH_OBSERVER(
       Observer, service_observers_,
       OnRemoteServiceStateUpdated(GetCurrentState(), "Authenticated"));
+  UpdatePollingDelay(kMinimumPollingDelaySeconds);
 
   may_have_unfetched_changes_ = true;
   MaybeStartFetchChanges();
 }
 
 void DriveFileSyncService::OnNetworkConnected() {
   if (state_ == REMOTE_SERVICE_OK)
     return;
   DVLOG(1) << "OnNetworkConnected";
   state_ = REMOTE_SERVICE_OK;
   if (GetCurrentState() != REMOTE_SERVICE_OK)
     return;
   FOR_EACH_OBSERVER(
       Observer, service_observers_,
       OnRemoteServiceStateUpdated(GetCurrentState(), "Network connected"));
+  UpdatePollingDelay(kMinimumPollingDelaySeconds);
 
   may_have_unfetched_changes_ = true;
   MaybeStartFetchChanges();
 }
 
 // Called by CreateForTesting.
 DriveFileSyncService::DriveFileSyncService(
     Profile* profile,
     const base::FilePath& base_dir,
     scoped_ptr<DriveFileSyncClientInterface> sync_client,
     scoped_ptr<DriveMetadataStore> metadata_store)
     : profile_(profile),
       last_operation_status_(SYNC_STATUS_OK),
       state_(REMOTE_SERVICE_OK),
       sync_enabled_(true),
       largest_fetched_changestamp_(0),
+      polling_delay_seconds_(-1),
       may_have_unfetched_changes_(false),
       remote_change_processor_(NULL),
       conflict_resolution_(kDefaultPolicy),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(profile);
   temporary_file_dir_ = base_dir.Append(kTempDirName);
 
   token_.reset(new TaskToken(AsWeakPtr()));
   sync_client_ = sync_client.Pass();
   metadata_store_ = metadata_store.Pass();
@@ skipping 30 matching lines @@
 
   if (token_->task_type() != TASK_TYPE_NONE) {
     DVLOG(2) << "NotifyTaskDone: " << token_->description()
              << ": finished with status=" << status
              << " (" << SyncStatusCodeToString(status) << ")"
              << " " << token_->location().ToString();
 
     RemoteServiceState old_state = GetCurrentState();
     UpdateServiceState();
 
+    // Reset the polling delay. This will adjust the polling timer
+    // based on the current service state.
+    UpdatePollingDelay(polling_delay_seconds_);
+
     // Notify remote sync service state if the state has been changed.
     if (!token_->description().empty() || old_state != GetCurrentState()) {
       FOR_EACH_OBSERVER(
           Observer, service_observers_,
           OnRemoteServiceStateUpdated(GetCurrentState(),
                                       token_->done_description()));
     }
   }
 
   token_->ResetTask(FROM_HERE);
   if (!pending_tasks_.empty()) {
     base::Closure closure = pending_tasks_.front();
     pending_tasks_.pop_front();
     closure.Run();
     return;
   }
 
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   MaybeStartFetchChanges();
 
+  SchedulePolling();
+
   // Notify observer of the update of |pending_changes_|.
   FOR_EACH_OBSERVER(Observer, service_observers_,
                     OnRemoteChangeQueueUpdated(pending_changes_.size()));
 }
 
 void DriveFileSyncService::UpdateServiceState() {
   switch (last_operation_status_) {
     // Possible regular operation errors.
     case SYNC_STATUS_OK:
     case SYNC_STATUS_FILE_BUSY:
@@ skipping 249 matching lines @@
             AsWeakPtr(), base::Passed(&token), origin, largest_changestamp));
     return;
   }
 
   // Move |origin| to the incremental sync origin set if the origin has no file.
   if (metadata_store_->IsBatchSyncOrigin(origin) &&
       !ContainsKey(origin_to_changes_map_, origin)) {
     metadata_store_->MoveBatchSyncOriginToIncremental(origin);
   }
 
-  may_have_unfetched_changes_ = true;
-  MaybeStartFetchChanges();
+  CheckForUpdates();
   NotifyTaskDone(SYNC_STATUS_OK, token.Pass());
 }
 
 void DriveFileSyncService::DidChangeOriginOnMetadataStore(
     scoped_ptr<TaskToken> token,
     const SyncStatusCallback& callback,
     SyncStatusCode status) {
   NotifyTaskDone(status, token.Pass());
   callback.Run(status);
 }
@@ skipping 1062 matching lines @@
     }
     return;
   }
 
   if (may_have_unfetched_changes_ &&
       !metadata_store_->incremental_sync_origins().empty()) {
     FetchChangesForIncrementalSync();
   }
 }
 
-void DriveFileSyncService::OnNotificationReceived() {
+void DriveFileSyncService::CheckForUpdates() {
   // TODO(calvinlo): Try to eliminate may_have_unfetched_changes_ variable.
   may_have_unfetched_changes_ = true;
   MaybeStartFetchChanges();
 }
 
 void DriveFileSyncService::FetchChangesForIncrementalSync() {
   scoped_ptr<TaskToken> token(GetToken(FROM_HERE, TASK_TYPE_DRIVE,
                                        "Fetching remote change list"));
   DCHECK(token);
   DCHECK(may_have_unfetched_changes_);
@@ skipping 69 matching lines @@
     metadata_store_->SetOriginRootDirectory(*itr, std::string());
   }
 
   GURL next_feed;
   if (changes->GetNextFeedURL(&next_feed))
     may_have_unfetched_changes_ = true;
 
   if (!changes->entries().empty())
     largest_fetched_changestamp_ = changes->entries().back()->changestamp();
 
+  if (has_new_changes) {
+    UpdatePollingDelay(kMinimumPollingDelaySeconds);
+  } else {
+    // If the change_queue_ was not updated, update the polling delay to wait
+    // longer.
+    UpdatePollingDelay(static_cast<int64>(
+        kDelayMultiplier * polling_delay_seconds_));
+  }
+
   NotifyTaskDone(SYNC_STATUS_OK, token.Pass());
 }
 
 bool DriveFileSyncService::GetOriginForEntry(
     const google_apis::ResourceEntry& entry,
     GURL* origin_out) {
   typedef ScopedVector<google_apis::Link>::const_iterator iterator;
   for (iterator itr = entry.links().begin();
        itr != entry.links().end(); ++itr) {
     if ((*itr)->type() != google_apis::Link::LINK_PARENT)
@@ skipping 11 matching lines @@
     if ((*itr)->href().GetOrigin() != resource_link.GetOrigin() ||
         (*itr)->href().path() != resource_link.path())
       continue;
 
     *origin_out = origin;
     return true;
   }
   return false;
 }
 
+void DriveFileSyncService::SchedulePolling() {
+  if (polling_timer_.IsRunning() ||
+      polling_delay_seconds_ < 0 ||
+      GetCurrentState() == REMOTE_SERVICE_DISABLED)
+    return;
+
+  DVLOG(1) << "Polling scheduled"
+           << " (delay:" << polling_delay_seconds_ << "s)";
+
+  polling_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(polling_delay_seconds_),
+      base::Bind(&DriveFileSyncService::OnPollingTimerFired, AsWeakPtr()));
+}
+
+void DriveFileSyncService::OnPollingTimerFired() {
+  may_have_unfetched_changes_ = true;
+  MaybeStartFetchChanges();
+}
+
+void DriveFileSyncService::UpdatePollingDelay(int64 new_delay_sec) {
+  // polling_delay_seconds_ made negative to disable polling for testing.
+  if (polling_delay_seconds_ < 0)
+    return;
+
+  if (state_ == REMOTE_SERVICE_TEMPORARY_UNAVAILABLE) {
+    // If the service state is TEMPORARY_UNAVAILABLE, poll the service
+    // with a modest duration (but more frequently than
+    // kPollingDelaySecondsWithNotification) so that we have a mild chance
+    // to recover the state.
+    polling_delay_seconds_ = kMaximumPollingDelaySeconds;
+    polling_timer_.Stop();
+    return;
+  }
+
+  int64 old_delay = polling_delay_seconds_;
+
+  // Push notifications off.
+  polling_delay_seconds_ = std::min(new_delay_sec, kMaximumPollingDelaySeconds);
+
+  if (polling_delay_seconds_ < old_delay)
+    polling_timer_.Stop();
+}
+
 void DriveFileSyncService::NotifyObserversFileStatusChanged(
     const FileSystemURL& url,
     SyncFileStatus sync_status,
     SyncAction action_taken,
     SyncDirection direction) {
   if (sync_status != SYNC_FILE_STATUS_SYNCED) {
     DCHECK_EQ(SYNC_ACTION_NONE, action_taken);
     DCHECK_EQ(SYNC_DIRECTION_NONE, direction);
   }
 
@@ skipping 66 matching lines @@
       pending_batch_sync_origins_.insert(origin);
   }
   callback.Run(status, resource_id);
 }
 
 std::string DriveFileSyncService::sync_root_resource_id() {
   return metadata_store_->sync_root_directory();
 }
 
 }  // namespace sync_file_system