Merge ChromeOS and SyncFS XMPP Notification into one class

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_webapps_registry.h"
 #include "chrome/browser/chromeos/drive/file_write_helper.h"
 #include "chrome/browser/chromeos/drive/stale_cache_files_remover.h"
 #include "chrome/browser/chromeos/drive/sync_client.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/event_logger.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 google_apis::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));
 
-  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;
-  }
+  google_apis::DriveNotificationManager* drive_notification_manager =
+      google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
+  if (drive_notification_manager)
+    drive_notification_manager->RemoveObserver(this);
 
   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();
   cache_->ClearAll(base::Bind(
       &DriveSystemService::ReinitializeResourceMetadataAfterClearCache,
       weak_ptr_factory_.GetWeakPtr(),
       callback));
@@ skipping 35 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   RemoveDriveMountPoint();
   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 59 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.
-  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;
-  }
+  google_apis::DriveNotificationManager* drive_notification_manager =
+      google_apis::DriveNotificationManagerFactory::GetForProfile(profile_);
+  if (drive_notification_manager)
+    drive_notification_manager->AddObserver(this);
 
   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(ProfileSyncServiceFactory::GetInstance());
+  DependsOn(google_apis::DriveNotificationManagerFactory::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