Enable Drive integration service in incognito windows.

chrome/browser/chromeos/drive/drive_integration_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_INTEGRATION_SERVICE_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_INTEGRATION_SERVICE_H_
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "chrome/browser/chromeos/drive/file_errors.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/drive/drive_notification_observer.h"
 #include "components/keyed_service/content/browser_context_keyed_service_factory.h"
 #include "components/keyed_service/core/keyed_service.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 }
 
 namespace drive {
 
 class DebugInfoCollector;
 class DownloadHandler;
@@ skipping 27 matching lines @@
 
 // DriveIntegrationService is used to integrate Drive to Chrome. This class
 // exposes the file system representation built on top of Drive and some
 // other Drive related objects to the file manager, and some other sub
 // systems.
 //
 // The class is essentially a container that manages lifetime of the objects
 // that are used to integrate Drive to Chrome. The object of this class is
 // created per-profile.
 class DriveIntegrationService : public KeyedService,
-                                public DriveNotificationObserver {
+                                public DriveNotificationObserver,
+                                public content::NotificationObserver {
  public:
   class PreferenceWatcher;
 
   // test_drive_service, test_mount_point_name, test_cache_root and
   // test_file_system are used by tests to inject customized instances.
   // Pass NULL or the empty value when not interested.
   // |preference_watcher| observes the drive enable preference, and sets the
   // enable state when changed. It can be NULL. The ownership is taken by
   // the DriveIntegrationService.
   DriveIntegrationService(
@@ skipping 65 matching lines @@
   void Initialize();
 
   // Called when metadata initialization is done. Continues initialization if
   // the metadata initialization is successful.
   void InitializeAfterMetadataInitialized(FileError error);
 
   // Change the download directory to the local "Downloads" if the download
   // destination is set under Drive. This must be called when disabling Drive.
   void AvoidDriveAsDownloadDirecotryPreference();
 
+  // content::NotificationObserver overrides.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
   friend class DriveIntegrationServiceFactory;
 
   Profile* profile_;
   State state_;
   bool enabled_;
   // Custom mount point name that can be injected for testing in constructor.
   std::string mount_point_name_;
 
   base::FilePath cache_root_directory_;
   scoped_ptr<EventLogger> logger_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<internal::ResourceMetadataStorage,
              util::DestroyHelper> metadata_storage_;
   scoped_ptr<internal::FileCache, util::DestroyHelper> cache_;
   scoped_ptr<DriveServiceInterface> drive_service_;
   scoped_ptr<JobScheduler> scheduler_;
   scoped_ptr<DriveAppRegistry> drive_app_registry_;
   scoped_ptr<internal::ResourceMetadata,
              util::DestroyHelper> resource_metadata_;
   scoped_ptr<FileSystemInterface> file_system_;
   scoped_ptr<DownloadHandler> download_handler_;
   scoped_ptr<DebugInfoCollector> debug_info_collector_;
 
   ObserverList<DriveIntegrationServiceObserver> observers_;
   scoped_ptr<PreferenceWatcher> preference_watcher_;
+  scoped_ptr<content::NotificationRegistrar> profile_notification_registrar_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<DriveIntegrationService> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveIntegrationService);
 };
 
 // Singleton that owns all instances of DriveIntegrationService and
 // associates them with Profiles.
 class DriveIntegrationServiceFactory
@@ skipping 29 matching lines @@
 
   // Returns the DriveIntegrationServiceFactory instance.
   static DriveIntegrationServiceFactory* GetInstance();
 
  private:
   friend struct DefaultSingletonTraits<DriveIntegrationServiceFactory>;
 
   DriveIntegrationServiceFactory();
   virtual ~DriveIntegrationServiceFactory();
 
-  // BrowserContextKeyedServiceFactory:
+  // BrowserContextKeyedServiceFactory overrides.
+  virtual content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const OVERRIDE;
   virtual KeyedService* BuildServiceInstanceFor(
       content::BrowserContext* context) const OVERRIDE;
 
   // This is static so it can be set without instantiating the factory. This
   // allows factory creation to be delayed until it normally happens (on profile
   // creation) rather than when tests are set up. DriveIntegrationServiceFactory
   // transitively depends on ExtensionSystemFactory which crashes if created too
   // soon (i.e. before the BrowserProcess exists).
   static FactoryCallback* factory_for_test_;
 };
 
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_INTEGRATION_SERVICE_H_