Merge ChromeOS and SyncFS XMPP Notification into one class

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 13 matching lines @@
 DriveFileSyncService::~DriveFileSyncService() {
   // Invalidate WeakPtr instances here explicitly to notify TaskToken that we
   // can safely discard the token.
   weak_factory_.InvalidateWeakPtrs();
   if (sync_client_)
     sync_client_->RemoveObserver(this);
   token_.reset();
 
   google_apis::DriveNotificationManager* drive_notification_manager =
       google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
-  DCHECK(drive_notification_manager);
-  drive_notification_manager->RemoveObserver(this);
+  if (drive_notification_manager)
+    drive_notification_manager->RemoveObserver(this);
 }
 
 // static
 scoped_ptr<DriveFileSyncService> DriveFileSyncService::CreateForTesting(
     Profile* profile,
     const base::FilePath& base_dir,
     scoped_ptr<DriveFileSyncClientInterface> sync_client,
     scoped_ptr<DriveMetadataStore> metadata_store) {
   return make_scoped_ptr(new DriveFileSyncService(
       profile, base_dir, sync_client.Pass(), metadata_store.Pass()));
@@ skipping 237 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 85 matching lines @@
   }
 
   if (!sync_root_resource_id().empty())
     sync_client_->EnsureSyncRootIsNotInMyDrive(sync_root_resource_id());
 
   NotifyTaskDone(status, token.Pass());
   may_have_unfetched_changes_ = true;
 
   google_apis::DriveNotificationManager* drive_notification_manager =
       google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
-  DCHECK(drive_notification_manager);
-  drive_notification_manager->AddObserver(this);
+  if (drive_notification_manager)
+    drive_notification_manager->AddObserver(this);
 }
 
 void DriveFileSyncService::UpdateRegisteredOrigins() {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   if (!extension_service)
     return;
 
   std::vector<GURL> origins;
   metadata_store_->GetAllOrigins(&origins);
@@ skipping 142 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);
   }
 
-  CheckForUpdates();
+  may_have_unfetched_changes_ = true;
+  MaybeStartFetchChanges();
   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 1061 matching lines @@
     }
     return;
   }
 
   if (may_have_unfetched_changes_ &&
       !metadata_store_->incremental_sync_origins().empty()) {
     FetchChangesForIncrementalSync();
   }
 }
 
-void DriveFileSyncService::CheckForUpdates() {
+void DriveFileSyncService::OnNotificationReceived() {
   // 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