Enable Drive integration service in incognito windows.

chrome/browser/chromeos/drive/download_handler.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/download_handler.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/supports_user_data.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 123 matching lines @@
 
   drive_tmp_download_path_ = drive_tmp_download_path;
 
   if (download_manager) {
     notifier_.reset(new AllDownloadItemNotifier(download_manager, this));
     // Remove any persisted Drive DownloadItem. crbug.com/171384
     content::DownloadManager::DownloadVector downloads;
     download_manager->GetAllDownloads(&downloads);
     for (size_t i = 0; i < downloads.size(); ++i) {
       if (IsPersistedDriveDownload(drive_tmp_download_path_, downloads[i]))
-        RemoveDownload(downloads[i]->GetId());
+        downloads[i]->Remove();
     }
   }
 }
 
+void DownloadHandler::ObserveIncognitoDownloadManager(
+    DownloadManager* download_manager) {
+  DCHECK(!notifier_incognito_);
+  notifier_incognito_.reset(new AllDownloadItemNotifier(download_manager,
+                                                        this));
+}
+
 void DownloadHandler::SubstituteDriveDownloadPath(
     const base::FilePath& drive_path,
     content::DownloadItem* download,
     const SubstituteDriveDownloadPathCallback& callback) {
   DVLOG(1) << "SubstituteDriveDownloadPath " << drive_path.value();
 
   SetDownloadParams(drive_path, download);
 
   if (util::IsUnderDriveMountPoint(drive_path)) {
     // Prepare the destination directory.
@@ skipping 57 matching lines @@
 
 void DownloadHandler::OnDownloadCreated(DownloadManager* manager,
                                         DownloadItem* download) {
   // Remove any persisted Drive DownloadItem. crbug.com/171384
   if (IsPersistedDriveDownload(drive_tmp_download_path_, download)) {
     // Remove download later, since doing it here results in a crash.
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&DownloadHandler::RemoveDownload,
                                        weak_ptr_factory_.GetWeakPtr(),
+                                       static_cast<void*>(manager),
                                        download->GetId()));
   }
 }
 
-void DownloadHandler::RemoveDownload(int id) {
-  DownloadManager* manager = notifier_->GetManager();
+void DownloadHandler::RemoveDownload(void* manager_id, int id) {
+  DownloadManager* manager = GetDownloadManager(manager_id);
   if (!manager)
     return;
   DownloadItem* download = manager->GetDownload(id);
   if (!download)
     return;
   download->Remove();
 }
 
 void DownloadHandler::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Only accept downloads that have the Drive meta data associated with them.
   DriveUserData* data = GetDriveUserData(download);
   if (!drive_tmp_download_path_.IsParent(download->GetTargetFilePath()) ||
       !data ||
       data->is_complete())
     return;
 
   switch (download->GetState()) {
     case DownloadItem::IN_PROGRESS:
       break;
 
     case DownloadItem::COMPLETE:
-      UploadDownloadItem(download);
+      UploadDownloadItem(manager, download);
       data->set_complete();
       break;
 
     case DownloadItem::CANCELLED:
       download->SetUserData(&kDrivePathKey, NULL);
       break;
 
     case DownloadItem::INTERRUPTED:
       // Interrupted downloads can be resumed. Keep the Drive user data around
       // so that it can be used when the download resumes. The download is truly
@@ skipping 15 matching lines @@
         FROM_HERE,
         base::Bind(&GetDriveTempDownloadPath, drive_tmp_download_path_),
         callback);
   } else {
     LOG(WARNING) << "Failed to create directory, error = "
                  << FileErrorToString(error);
     callback.Run(base::FilePath());
   }
 }
 
-void DownloadHandler::UploadDownloadItem(DownloadItem* download) {
+void DownloadHandler::UploadDownloadItem(DownloadManager* manager,
+                                         DownloadItem* download) {
   DCHECK_EQ(DownloadItem::COMPLETE, download->GetState());
   base::FilePath* cache_file_path = new base::FilePath;
   WriteOnCacheFileAndReply(
       file_system_,
       util::ExtractDrivePath(GetTargetPath(download)),
       download->GetMimeType(),
       base::Bind(&MoveDownloadedFile, download->GetTargetFilePath(),
                  cache_file_path),
       base::Bind(&DownloadHandler::SetCacheFilePath,
                  weak_ptr_factory_.GetWeakPtr(),
+                 static_cast<void*>(manager),
                  download->GetId(),
                  base::Owned(cache_file_path)));
 }
 
-void DownloadHandler::SetCacheFilePath(int id,
+void DownloadHandler::SetCacheFilePath(void* manager_id,
+                                       int id,
                                        const base::FilePath* cache_file_path,
                                        FileError error) {
   if (error != FILE_ERROR_OK)
     return;
-  DownloadManager* manager = notifier_->GetManager();
+  DownloadManager* manager = GetDownloadManager(manager_id);
   if (!manager)
     return;
   DownloadItem* download = manager->GetDownload(id);
   if (!download)
     return;
   DriveUserData* data = GetDriveUserData(download);
   if (!data)
     return;
   data->set_cache_file_path(*cache_file_path);
 }
 
+DownloadManager* DownloadHandler::GetDownloadManager(void* manager_id) {
+  if (manager_id == notifier_->GetManager())
+    return notifier_->GetManager();
+  if (notifier_incognito_ && manager_id == notifier_incognito_->GetManager())
+    return notifier_incognito_->GetManager();
+  return NULL;
+}
 
 }  // namespace drive