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

trunk/src/chrome/browser/chromeos/drive/drive_system_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/chromeos/drive/drive_system_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_download_handler.h"
 #include "chrome/browser/chromeos/drive/drive_file_system.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_proxy.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_prefetcher.h"
 #include "chrome/browser/chromeos/drive/drive_sync_client.h"
 #include "chrome/browser/chromeos/drive/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/drive/event_logger.h"
 #include "chrome/browser/chromeos/drive/file_write_helper.h"
 #include "chrome/browser/chromeos/drive/stale_cache_files_remover.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/google_apis/auth_service.h"
 #include "chrome/browser/google_apis/drive_api_service.h"
 #include "chrome/browser/google_apis/drive_api_util.h"
-#include "chrome/browser/google_apis/drive_notification_manager.h"
-#include "chrome/browser/google_apis/drive_notification_manager_factory.h"
 #include "chrome/browser/google_apis/gdata_wapi_service.h"
 #include "chrome/browser/google_apis/gdata_wapi_url_generator.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
+#include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "google/cacheinvalidation/types.pb.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/user_agent/user_agent_util.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace drive {
 namespace {
 
 static const size_t kEventLogHistorySize = 100;
 
+// The sync invalidation object ID for Google Drive.
+const char kDriveInvalidationObjectId[] = "CHANGELOG";
+
 // Returns true if Drive is enabled for the given Profile.
 bool IsDriveEnabledForProfile(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!google_apis::AuthService::CanAuthenticate(profile))
     return false;
 
   // Disable Drive if preference is set.  This can happen with commandline flag
   // --disable-gdata or enterprise policy, or probably with user settings too
   // in the future.
@@ skipping 34 matching lines @@
 
 }  // namespace
 
 DriveSystemService::DriveSystemService(
     Profile* profile,
     google_apis::DriveServiceInterface* test_drive_service,
     const base::FilePath& test_cache_root,
     DriveFileSystemInterface* test_file_system)
     : profile_(profile),
       drive_disabled_(false),
+      push_notification_registered_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::SequencedWorkerPool* blocking_pool = BrowserThread::GetBlockingPool();
   blocking_task_runner_ = blocking_pool->GetSequencedTaskRunner(
       blocking_pool->GetSequenceToken());
 
   event_logger_.reset(new EventLogger(kEventLogHistorySize));
   if (test_drive_service) {
     drive_service_.reset(test_drive_service);
   } else if (google_apis::util::IsDriveV2ApiEnabled()) {
@@ skipping 49 matching lines @@
   drive_service_->Initialize(profile_);
   file_system_->Initialize();
   cache_->RequestInitialize(
       base::Bind(&DriveSystemService::InitializeAfterCacheInitialized,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveSystemService::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  google_apis::DriveNotificationManager* drive_notification_manager =
-      google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
-  DCHECK(drive_notification_manager);
-  drive_notification_manager->RemoveObserver(this);
+  ProfileSyncService* profile_sync_service =
+      profile_ ? ProfileSyncServiceFactory::GetForProfile(profile_) : NULL;
+  if (profile_sync_service && push_notification_registered_) {
+    // TODO(kochi): Once DriveSystemService gets started / stopped at runtime,
+    // this ID needs to be unregistered *before* the handler is unregistered
+    // as ID persists across browser restarts.
+    if (!IsDriveEnabledForProfile(profile_)) {
+      profile_sync_service->UpdateRegisteredInvalidationIds(
+          this, syncer::ObjectIdSet());
+    }
+    profile_sync_service->UnregisterInvalidationHandler(this);
+    push_notification_registered_ = false;
+  }
 
   RemoveDriveMountPoint();
 }
 
 void DriveSystemService::AddObserver(DriveSystemServiceObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
 void DriveSystemService::RemoveObserver(DriveSystemServiceObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
-void DriveSystemService::OnNotificationReceived() {
-  file_system_->CheckForUpdates();
-}
-
 bool DriveSystemService::IsDriveEnabled() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!IsDriveEnabledForProfile(profile_))
     return false;
 
   // Drive may be disabled for cache initialization failure, etc.
   if (drive_disabled_)
     return false;
 
   return true;
 }
 
+void DriveSystemService::OnInvalidatorStateChange(
+    syncer::InvalidatorState state) {
+  DVLOG(1) << "InvalidatorState changed to " << state;
+}
+
+void DriveSystemService::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));
+
+  file_system_->CheckForUpdates();
+}
+
 void DriveSystemService::ClearCacheAndRemountFileSystem(
     const base::Callback<void(bool)>& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   RemoveDriveMountPoint();
   drive_service()->CancelAll();
   cache_->ClearAll(base::Bind(
       &DriveSystemService::ReinitializeResourceMetadataAfterClearCache,
       weak_ptr_factory_.GetWeakPtr(),
@@ skipping 37 matching lines @@
 
   RemoveDriveMountPoint();
   drive_service()->CancelAll();
   file_system_->Reload();
 
   // Reload() is asynchronous. But we can add back the mount point right away
   // because every operation waits until loading is complete.
   AddDriveMountPoint();
 }
 
+bool DriveSystemService::PushNotificationEnabled() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(profile_);
+
+  ProfileSyncService* profile_sync_service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+  if (!profile_sync_service)
+    return false;
+
+  return (profile_sync_service->GetInvalidatorState() ==
+          syncer::INVALIDATIONS_ENABLED);
+}
+
 void DriveSystemService::AddDriveMountPoint() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!file_system_proxy_.get());
 
   const base::FilePath drive_mount_point = util::GetDriveMountPointPath();
   fileapi::ExternalMountPoints* mount_points =
       BrowserContext::GetMountPoints(profile_);
   DCHECK(mount_points);
 
   file_system_proxy_ = new DriveFileSystemProxy(file_system_.get());
@@ skipping 57 matching lines @@
   }
 
   content::DownloadManager* download_manager =
     g_browser_process->download_status_updater() ?
         BrowserContext::GetDownloadManager(profile_) : NULL;
   download_handler_->Initialize(
       download_manager,
       cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_TMP_DOWNLOADS));
 
   // Register for Google Drive invalidation notifications.
-  google_apis::DriveNotificationManager* drive_notification_manager =
-      google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
-  DCHECK(drive_notification_manager);
-  drive_notification_manager->AddObserver(this);
+  ProfileSyncService* profile_sync_service =
+      profile_ ? ProfileSyncServiceFactory::GetForProfile(profile_) : NULL;
+  if (profile_sync_service) {
+    DCHECK(!push_notification_registered_);
+    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;
+  }
 
   AddDriveMountPoint();
 }
 
 void DriveSystemService::DisableDrive() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drive_disabled_ = true;
   // Change the download directory to the default value if the download
   // destination is set to under Drive mount point.
@@ skipping 48 matching lines @@
 
 // static
 void DriveSystemServiceFactory::SetFactoryForTest(
     const FactoryCallback& factory_for_test) {
   GetInstance()->factory_for_test_ = factory_for_test;
 }
 
 DriveSystemServiceFactory::DriveSystemServiceFactory()
     : ProfileKeyedServiceFactory("DriveSystemService",
                                  ProfileDependencyManager::GetInstance()) {
-  DependsOn(google_apis::DriveNotificationManagerFactory::GetInstance());
+  DependsOn(ProfileSyncServiceFactory::GetInstance());
   DependsOn(DownloadServiceFactory::GetInstance());
 }
 
 DriveSystemServiceFactory::~DriveSystemServiceFactory() {
 }
 
 ProfileKeyedService* DriveSystemServiceFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   DriveSystemService* service = NULL;
   if (factory_for_test_.is_null())
     service = new DriveSystemService(profile, NULL, base::FilePath(), NULL);
   else
     service = factory_for_test_.Run(profile);
 
   service->Initialize();
   return service;
 }
 
 }  // namespace drive