Enable Drive integration service in incognito windows.

chrome/browser/chromeos/drive/drive_integration_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_integration_service.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/drive/debug_info_collector.h"
 #include "chrome/browser/chromeos/drive/download_handler.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/resource_metadata.h"
 #include "chrome/browser/chromeos/drive/resource_metadata_storage.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/chromeos/profiles/profile_util.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/drive/drive_api_service.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/drive/drive_app_registry.h"
 #include "chrome/browser/drive/drive_notification_manager.h"
 #include "chrome/browser/drive/drive_notification_manager_factory.h"
 #include "chrome/browser/drive/event_logger.h"
+#include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/common/user_agent.h"
 #include "google_apis/drive/auth_service.h"
 #include "google_apis/drive/gdata_wapi_url_generator.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
@@ skipping 161 matching lines @@
     const base::FilePath& test_cache_root,
     FileSystemInterface* test_file_system)
     : profile_(profile),
       state_(NOT_INITIALIZED),
       enabled_(false),
       mount_point_name_(test_mount_point_name),
       cache_root_directory_(!test_cache_root.empty() ?
                             test_cache_root : util::GetCacheRootPath(profile)),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(profile && !profile->IsOffTheRecord());
 
   logger_.reset(new EventLogger);
   base::SequencedWorkerPool* blocking_pool = BrowserThread::GetBlockingPool();
   blocking_task_runner_ = blocking_pool->GetSequencedTaskRunner(
       blocking_pool->GetSequenceToken());
 
   ProfileOAuth2TokenService* oauth_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
 
   if (test_drive_service) {
@@ skipping 267 matching lines @@
 
     // Cannot used Drive. Set the download destination preference out of Drive.
     AvoidDriveAsDownloadDirecotryPreference();
 
     // Back to NOT_INITIALIZED state. Then, re-running Initialize() should
     // work if the error is recoverable manually (such as out of disk space).
     state_ = NOT_INITIALIZED;
     return;
   }
 
+  // Initialize Download Handler for hooking downloads to the Drive folder.
   content::DownloadManager* download_manager =
       g_browser_process->download_status_updater() ?
       BrowserContext::GetDownloadManager(profile_) : NULL;
   download_handler_->Initialize(
       download_manager,
       cache_root_directory_.Append(kTemporaryFileDirectory));
 
+  // Installs the handler also to incognito profile.

[hashimoto, 2014/06/03 06:10:32]

nit-picking-nit: s/Installs/Install/

[kinaba, 2014/06/03 06:50:32]

Done.

+  if (g_browser_process->download_status_updater()) {
+    if (profile_->HasOffTheRecordProfile()) {
+      download_handler_->ObserveIncognitoDownloadManager(
+          BrowserContext::GetDownloadManager(
+              profile_->GetOffTheRecordProfile()));
+    } else {
+      profile_notification_registrar_.reset(new content::NotificationRegistrar);
+      profile_notification_registrar_->Add(
+          this,
+          chrome::NOTIFICATION_PROFILE_CREATED,
+          content::NotificationService::AllSources());
+    }
+  }
+
   // Register for Google Drive invalidation notifications.
   DriveNotificationManager* drive_notification_manager =
       DriveNotificationManagerFactory::GetForBrowserContext(profile_);
   if (drive_notification_manager) {
     drive_notification_manager->AddObserver(this);
     const bool registered =
         drive_notification_manager->push_notification_registered();
     const char* status = (registered ? "registered" : "not registered");
     logger_->Log(logging::LOG_INFO, "Push notification is %s", status);
 
@@ skipping 13 matching lines @@
 void DriveIntegrationService::AvoidDriveAsDownloadDirecotryPreference() {
   PrefService* pref_service = profile_->GetPrefs();
   if (util::IsUnderDriveMountPoint(
           pref_service->GetFilePath(prefs::kDownloadDefaultDirectory))) {
     pref_service->SetFilePath(
         prefs::kDownloadDefaultDirectory,
         file_manager::util::GetDownloadsFolderForProfile(profile_));
   }
 }
 
+void DriveIntegrationService::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  if (type == chrome::NOTIFICATION_PROFILE_CREATED) {
+    Profile* created_profile = content::Source<Profile>(source).ptr();
+    if (created_profile->IsOffTheRecord() &&
+        created_profile->IsSameProfile(profile_)) {
+      download_handler_->ObserveIncognitoDownloadManager(
+          BrowserContext::GetDownloadManager(created_profile));
+      profile_notification_registrar_->Remove(
+          this,
+          chrome::NOTIFICATION_PROFILE_CREATED,
+          content::NotificationService::AllSources());
+    }
+  }
+}
+
 //===================== DriveIntegrationServiceFactory =======================
 
 DriveIntegrationServiceFactory::FactoryCallback*
     DriveIntegrationServiceFactory::factory_for_test_ = NULL;
 
 DriveIntegrationServiceFactory::ScopedFactoryForTest::ScopedFactoryForTest(
     FactoryCallback* factory_for_test) {
   factory_for_test_ = factory_for_test;
 }
 
@@ skipping 39 matching lines @@
         "DriveIntegrationService",
         BrowserContextDependencyManager::GetInstance()) {
   DependsOn(ProfileOAuth2TokenServiceFactory::GetInstance());
   DependsOn(DriveNotificationManagerFactory::GetInstance());
   DependsOn(DownloadServiceFactory::GetInstance());
 }
 
 DriveIntegrationServiceFactory::~DriveIntegrationServiceFactory() {
 }
 
+content::BrowserContext* DriveIntegrationServiceFactory::GetBrowserContextToUse(
+    content::BrowserContext* context) const {
+  return chrome::GetBrowserContextRedirectedInIncognito(context);
+}
+
 KeyedService* DriveIntegrationServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   Profile* profile = Profile::FromBrowserContext(context);
 
   DriveIntegrationService* service = NULL;
   if (!factory_for_test_) {
     DriveIntegrationService::PreferenceWatcher* preference_watcher = NULL;
     if (chromeos::IsProfileAssociatedWithGaiaAccount(profile)) {
       // Drive File System can be enabled.
       preference_watcher =
           new DriveIntegrationService::PreferenceWatcher(profile->GetPrefs());
     }
 
     service = new DriveIntegrationService(
         profile, preference_watcher,
         NULL, std::string(), base::FilePath(), NULL);
   } else {
     service = factory_for_test_->Run(profile);
   }
 
   return service;
 }
 
 }  // namespace drive