drive: Add Profile* as a member of DriveProtocolHandler.

chrome/browser/chromeos/drive/drive_protocol_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/drive_protocol_handler.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/drive/drive_system_service.h"
 #include "chrome/browser/google_apis/drive_service_interface.h"
 #include "chrome/browser/google_apis/gdata_errorcode.h"
 #include "chrome/browser/google_apis/time_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 55 matching lines @@
       path.size() <= drive_schema.size()) {
     return false;
   }
 
   std::string id = path.substr(drive_schema.size());
   *resource_id = net::UnescapeURLComponent(id, kUrlPathUnescapeMask);
   return resource_id->size();
 }
 
 // Helper function to get DriveSystemService from Profile.
-DriveSystemService* GetSystemService() {
-  return DriveSystemServiceFactory::GetForProfile(
-      ProfileManager::GetDefaultProfile());
+DriveSystemService* GetSystemService(void* profile_id) {
+  Profile* profile = reinterpret_cast<Profile*>(profile_id);
+  if (!g_browser_process->profile_manager()->IsValidProfile(profile))
+    return NULL;
+
+  return DriveSystemServiceFactory::GetForProfile(profile);
 }
 
 // Helper function to get DriveFileSystem from Profile on UI thread.
-DriveFileSystemInterface* GetFileSystemOnUIThread() {
-  DriveSystemService* system_service = GetSystemService();
+DriveFileSystemInterface* GetFileSystemOnUIThread(void* profile_id) {
+  DriveSystemService* system_service = GetSystemService(profile_id);
   return system_service ? system_service->file_system() : NULL;
 }
 
 // Helper function to cancel Drive download operation on UI thread.
-void CancelDriveDownloadOnUIThread(const FilePath& drive_file_path) {
-  DriveSystemService* system_service = GetSystemService();
+void CancelDriveDownloadOnUIThread(
+    void* profile_id, const FilePath& drive_file_path) {
+  DriveSystemService* system_service = GetSystemService(profile_id);
   if (system_service)
     system_service->drive_service()->CancelForFilePath(drive_file_path);
 }
 
 // DriveURLRequesetJob is the gateway between network-level drive://...
 // requests for drive resources and DriveFileSytem.  It exposes content URLs
 // formatted as drive://<resource-id>.
 class DriveURLRequestJob : public net::URLRequestJob {
  public:
-  DriveURLRequestJob(net::URLRequest* request,
+  DriveURLRequestJob(void* profile_id,
+                     net::URLRequest* request,
                      net::NetworkDelegate* network_delegate);
 
   // net::URLRequestJob overrides:
   virtual void Start() OVERRIDE;
   virtual void Kill() OVERRIDE;
   virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE;
   virtual int GetResponseCode() const OVERRIDE;
   virtual bool ReadRawData(net::IOBuffer* buf,
                            int buf_size,
@@ skipping 52 matching lines @@
 
   // Helper methods to formulate and notify about response status, info and
   // headers.
   void NotifySuccess();
   void NotifyFailure(int);
   void HeadersCompleted(int status_code, const std::string& status_txt);
 
   // Helper method to close |stream_|.
   void CloseFileStream();
 
+  // The profile for processing Drive accesses. Should not be NULL and needs to
+  // be checked with ProfileManager::IsValidProfile before using it.
+  void* profile_id_;
   DriveFileSystemInterface* file_system_;
 
   bool error_;  // True if we've encountered an error.
   bool headers_set_;  // True if headers have been set.
 
   FilePath local_file_path_;
   FilePath drive_file_path_;
   std::string mime_type_;
   int64 initial_file_size_;
   int64 remaining_bytes_;
   scoped_ptr<net::FileStream> stream_;
   scoped_refptr<net::DrainableIOBuffer> read_buf_;
   scoped_ptr<net::HttpResponseInfo> response_info_;
   bool streaming_download_;
   scoped_refptr<net::GrowableIOBuffer> download_growable_buf_;
   scoped_refptr<net::DrainableIOBuffer> download_drainable_buf_;
 
   // This should remain the last member so it'll be destroyed first and
   // invalidate its weak pointers before other members are destroyed.
   base::WeakPtrFactory<DriveURLRequestJob> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveURLRequestJob);
 };
 
-DriveURLRequestJob::DriveURLRequestJob(net::URLRequest* request,
+DriveURLRequestJob::DriveURLRequestJob(void* profile_id,
+                                       net::URLRequest* request,
                                        net::NetworkDelegate* network_delegate)
     : net::URLRequestJob(request, network_delegate),
+      profile_id_(profile_id),
       file_system_(NULL),
       error_(false),
       headers_set_(false),
       initial_file_size_(0),
       remaining_bytes_(0),
       streaming_download_(false),
       download_growable_buf_(new net::GrowableIOBuffer),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   download_growable_buf_->SetCapacity(kInitialDownloadBufferSizeInBytes);
   download_drainable_buf_ = new net::DrainableIOBuffer(
@@ skipping 58 matching lines @@
   // - gotten size of physical file if file exists in cache.
 
   // Request job is created and runs on IO thread but getting file system via
   // profile needs to happen on UI thread, so post GetFileSystemOnUIThread to
   // UI thread; StartAsync reply task will proceed with actually starting the
   // request.
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&GetFileSystemOnUIThread),
+      base::Bind(&GetFileSystemOnUIThread, profile_id_),
       base::Bind(&DriveURLRequestJob::StartAsync,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveURLRequestJob::Kill() {
   DVLOG(1) << "Killing request";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   CloseFileStream();
 
   // If download operation for drive file (via
   // DriveFileSystem::GetFileByResourceId) is still in progress, cancel it by
   // posting a task on the UI thread.
   // Download operation is still in progress if:
   // 1) |local_file_path_| is still empty; it gets filled when callback for
   //    GetFileByResourceId is called, AND
   // 2) we're still streaming download data i.e. |remaining_bytes_| > 0; if
   //    we've finished streaming data, we want to avoid possibly killing last
   //    part of the download process where the last chunk is written to file;
   //    if we're reading directly from cache file, |remaining_bytes_| doesn't
   //    matter 'cos |local_file_path_| will not be empty.
   if (file_system_ && !drive_file_path_.empty() && local_file_path_.empty() &&
       remaining_bytes_ > 0) {
     DVLOG(1) << "Canceling download operation for " << drive_file_path_.value();
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&CancelDriveDownloadOnUIThread,
+                   profile_id_,
                    drive_file_path_));
   }
 
   net::URLRequestJob::Kill();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 bool DriveURLRequestJob::GetMimeType(std::string* mime_type) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   mime_type->assign(FixupMimeType(mime_type_));
@@ skipping 568 matching lines @@
   headers_set_ = true;
 
   NotifyHeadersComplete();
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // DriveProtocolHandler class
 
-DriveProtocolHandler::DriveProtocolHandler() {
+DriveProtocolHandler::DriveProtocolHandler(void* profile_id)
+  : profile_id_(profile_id) {
 }
 
 DriveProtocolHandler::~DriveProtocolHandler() {
 }
 
 net::URLRequestJob* DriveProtocolHandler::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   DVLOG(1) << "Handling url: " << request->url().spec();
-  return new DriveURLRequestJob(request, network_delegate);
+  return new DriveURLRequestJob(profile_id_, request, network_delegate);
 }
 
 }  // namespace drive