Ports XMPP Invalidation code from drive_file_sync_service in /sync_file_system to /google_apis/driv…

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>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/google_apis/drive_notification_manager.h"
+#include "chrome/browser/google_apis/drive_notification_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync_file_system/conflict_resolution_policy.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_client.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_util.h"
 #include "chrome/browser/sync_file_system/drive_metadata_store.h"
 #include "chrome/browser/sync_file_system/file_status_observer.h"
 #include "chrome/browser/sync_file_system/remote_change_processor.h"
 #include "chrome/browser/sync_file_system/sync_file_system.pb.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/constants.h"
-#include "google/cacheinvalidation/types.pb.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/syncable/sync_file_metadata.h"
 #include "webkit/fileapi/syncable/sync_file_type.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 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");
 
-// The sync invalidation object ID for Google Drive.
-const char kDriveInvalidationObjectId[] = "CHANGELOG";
-
 // 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) {
@@ skipping 85 matching lines @@
 
  private:
   base::WeakPtr<DriveFileSyncService> sync_service_;
   tracked_objects::Location location_;
   TaskType task_type_;
   std::string description_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskToken);
 };
 
-void DriveFileSyncService::OnInvalidatorStateChange(
-    syncer::InvalidatorState state) {
-  SetPushNotificationEnabled(state);
-}
-
-void DriveFileSyncService::OnIncomingInvalidation(
-    const syncer::ObjectIdInvalidationMap& invalidation_map) {
-  DCHECK_EQ(1U, invalidation_map.size());
-  const invalidation::ObjectId object_id(
-      ipc::invalidation::ObjectSource::COSMO_CHANGELOG,
-      kDriveInvalidationObjectId);
-  DCHECK_EQ(1U, invalidation_map.count(object_id));
-  // TODO(dcheng): Only acknowledge the invalidation once the fetch has
-  // completed. http://crbug.com/156843
-  ProfileSyncService* profile_sync_service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  CHECK(profile_sync_service);
-  profile_sync_service->AcknowledgeInvalidation(
-      invalidation_map.begin()->first,
-      invalidation_map.begin()->second.ack_handle);
-
-  may_have_unfetched_changes_ = true;
-  MaybeStartFetchChanges();
-}
-
 struct DriveFileSyncService::ProcessRemoteChangeParam {
   scoped_ptr<TaskToken> token;
   RemoteChange remote_change;
   SyncFileCallback callback;
 
   DriveMetadata drive_metadata;
   SyncFileMetadata local_metadata;
   bool metadata_updated;
   base::FilePath temporary_file_path;
   std::string md5_checksum;
@@ skipping 104 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),
-      push_notification_registered_(false),
-      push_notification_enabled_(false),
       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));
@@ skipping 12 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();
 
-  // Unregister for Drive notifications.
-  ProfileSyncService* profile_sync_service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  if (!profile_sync_service || !push_notification_registered_) {
-    return;
-  }
-
-  // TODO(calvinlo): Revisit this later in Consolidate Drive XMPP Notification
-  // and Polling Backup into one Class patch. http://crbug/173339.
-  // Original comment from Kochi about the order this is done in:
-  // Once DriveSystemService gets started / stopped at runtime, this ID needs to
-  // be unregistered *before* the handler is unregistered
-  // as ID persists across browser restarts.
-  profile_sync_service->UpdateRegisteredInvalidationIds(
-      this, syncer::ObjectIdSet());
-  profile_sync_service->UnregisterInvalidationHandler(this);
+  google_apis::DriveNotificationManager* drive_notification_manager =
+      google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
+  DCHECK(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 367 matching lines @@
 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),
-      push_notification_registered_(false),
-      push_notification_enabled_(false),
       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();
@@ skipping 160 matching lines @@
     DriveMetadata metadata;
     const FileSystemURL& url = itr->first;
     const std::string& resource_id = itr->second;
     AppendFetchChange(url.origin(), url.path(), resource_id);
   }
 
   if (!sync_root_resource_id().empty())
     sync_client_->EnsureSyncRootIsNotInMyDrive(sync_root_resource_id());
 
   NotifyTaskDone(status, token.Pass());
-  RegisterDriveNotifications();
   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);
 }
 
 void DriveFileSyncService::UpdateRegisteredOrigins() {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   if (!extension_service)
     return;
 
   // TODO(nhiroki): clean up these loops with similar bodies.
   // http://crbug.com/211600
@@ skipping 168 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);
   }
 
-  // If this was the last batch sync origin and push_notification is enabled
-  // (indicates that we may have longer polling cycle), trigger the first
-  // incremental sync on next task cycle.
-  if (pending_batch_sync_origins_.empty() &&
-      push_notification_enabled_) {
-    may_have_unfetched_changes_ = true;

[tzik, 2013/04/12 02:00:15]

Any alternate for this?

[calvinlo, 2013/04/12 04:42:00]

I think in general I want to get rid of the "may_have_unfetched_changes"
variable so only DriveNotificationManager manages when new changes should be
checked. Everytime CheckForUpdates() is called, may_have_unfetched_changes would
implicitly be true. If we can make that assertion true, then we can remove all
references to may_have_unfetched_changes in this file and thus this block would
no longer be needed.

[tzik, 2013/04/12 05:12:46]

I think we still need to kick CheckForUpdates around here, since the
notification has been ignored before this point.
So, how about just call CheckForUpdate here instead?

[calvinlo, 2013/04/12 06:44:38]

Done. Yeah, I agree, calling CheckForUpdates here is probably the safest thing
to do even thought it might not be the most optimized.

-  }
-
   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 1050 matching lines @@
     return;
   }
 
   if (may_have_unfetched_changes_ &&
       !metadata_store_->incremental_sync_origins().empty()) {
     FetchChangesForIncrementalSync();
   }
 }
 
 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_);
   DCHECK(pending_batch_sync_origins_.empty());
   DCHECK(!metadata_store_->incremental_sync_origins().empty());
@@ skipping 141 matching lines @@
   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;
   }
 
-  if (push_notification_enabled_) {
-    polling_delay_seconds_ = kPollingDelaySecondsWithNotification;
-    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();
 }
 
-bool DriveFileSyncService::IsDriveNotificationSupported() {
-  // TODO(calvinlo): A invalidation ID can only be registered to one handler.
-  // Therefore ChromeOS and SyncFS cannot both use XMPP notifications until
-  // (http://crbug.com/173339) is completed.
-  // For now, disable XMPP notifications for SyncFC on ChromeOS to guarantee
-  // that ChromeOS's file manager can register itself to the invalidationID.
-
-#if defined(OS_CHROMEOS)
-  return false;
-#else
-  return true;
-#endif
-}
-
-// Register for Google Drive invalidation notifications through XMPP.
-void DriveFileSyncService::RegisterDriveNotifications() {
-  // Push notification registration might have already occurred if called from
-  // a different extension.
-  if (!IsDriveNotificationSupported() || push_notification_registered_)
-    return;
-
-  ProfileSyncService* profile_sync_service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  if (!profile_sync_service)
-    return;
-
-  profile_sync_service->RegisterInvalidationHandler(this);
-  syncer::ObjectIdSet ids;
-  ids.insert(invalidation::ObjectId(
-      ipc::invalidation::ObjectSource::COSMO_CHANGELOG,
-      kDriveInvalidationObjectId));
-  profile_sync_service->UpdateRegisteredInvalidationIds(this, ids);
-  push_notification_registered_ = true;
-  SetPushNotificationEnabled(profile_sync_service->GetInvalidatorState());
-}
-
-void DriveFileSyncService::SetPushNotificationEnabled(
-    syncer::InvalidatorState state) {
-  push_notification_enabled_ = (state == syncer::INVALIDATIONS_ENABLED);
-  if (!push_notification_enabled_)
-    return;
-
-  // Push notifications are enabled so reset polling timer.
-  UpdatePollingDelay(kPollingDelaySecondsWithNotification);
-}
-
 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