Fourth patch in getting rid of caching MessageLoop pointers.

chrome/browser/download/save_file_manager.h

 // Copyright (c) 2006-2008 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.
 //
 // Objects that handle file operations for saving files, on the file thread.
 //
 // The SaveFileManager owns a set of SaveFile objects, each of which connects
 // with a SaveItem object which belongs to one SavePackage and runs on the file
 // thread for saving data in order to avoid disk activity on either network IO
 // thread or the UI thread. It coordinates the notifications from the network
@@ skipping 54 matching lines @@
 #include "base/hash_tables.h"
 #include "base/ref_counted.h"
 #include "chrome/browser/download/save_types.h"
 
 namespace net {
 class IOBuffer;
 }
 class GURL;
 class SaveFile;
 class SavePackage;
-class MessageLoop;
 class ResourceDispatcherHost;
 class Task;
 class URLRequestContextGetter;
 
 class SaveFileManager
     : public base::RefCountedThreadSafe<SaveFileManager> {
  public:
-  SaveFileManager(MessageLoop* ui_loop,
-                  MessageLoop* io_loop,
-                  ResourceDispatcherHost* rdh);
+  SaveFileManager(ResourceDispatcherHost* rdh);
   ~SaveFileManager();
 
   // Lifetime management.
   void Shutdown();
 
   // Called on the IO thread
   int GetNextId();
 
   // Save the specified URL. Called on the UI thread and forwarded to the
   // ResourceDispatcherHost on the IO thread.
@@ skipping 24 matching lines @@
 #if !defined(OS_MACOSX)
   // Handler for shell operations sent from the UI to the file thread. Mac OS X
   // requires opening downloads on the UI thread, so it does not use this
   // method.
   void OnShowSavedFileInShell(const FilePath full_path);
 #endif
 
   // Helper function for deleting specified file.
   void DeleteDirectoryOrFile(const FilePath& full_path, bool is_dir);
 
-  // For posting notifications from the UI and file threads.
-  MessageLoop* ui_loop() const { return ui_loop_; }
-  MessageLoop* file_loop() const { return file_loop_; }
-
   // Runs on file thread to save a file by copying from file system when
   // original url is using file scheme.
   void SaveLocalFile(const GURL& original_file_url,
                      int save_id,
                      int render_process_id);
 
   // Renames all the successfully saved files.
   // |final_names| points to a vector which contains pairs of save ids and
   // final names of successfully saved files.
   void RenameAllFiles(
       const FinalNameList& final_names,
       const FilePath& resource_dir,
       int render_process_id,
       int render_view_id);
 
   // When the user cancels the saving, we need to remove all remaining saved
   // files of this page saving job from save_file_map_.
   void RemoveSavedFileFromFileMap(const SaveIDList & save_ids);
 
  private:
   // A cleanup helper that runs on the file thread.
   void OnShutdown();
 
-  // The resource does not come from the network, but we still needs to call
-  // this function for getting unique save ID by calling
-  // OnRequireSaveJobFromOtherSource in the net IO thread and start saving
-  // operation. This function is called on the UI thread.
-  void RequireSaveJobFromOtherSource(SaveFileCreateInfo* info);
-
   // Called only on UI thread to get the SavePackage for a tab's profile.
   static SavePackage* GetSavePackageFromRenderIds(int render_process_id,
                                                   int review_view_id);
 
   // Register a starting request. Associate the save URL with a
   // SavePackage for further matching.
   void RegisterStartingRequest(const GURL& save_url,
                                SavePackage* save_package);
   // Unregister a start request according save URL, disassociate
   // the save URL and SavePackage.
@@ skipping 19 matching lines @@
   // If the SavePackage for this saving job is gone, cancel the request.
   void OnUpdateSaveProgress(int save_id,
                             int64 bytes_so_far,
                             bool write_success);
   // Update the SavePackage with the finish state, and remove the request
   // tracking entries.
   void OnSaveFinished(int save_id, int64 bytes_so_far, bool is_success);
   // For those requests that do not have valid save id, use
   // map:(url, SavePackage) to find the request and remove it.
   void OnErrorFinished(GURL save_url, int tab_id);
-  // Handler for a notification sent to the UI thread.
-  // The user has requested a cancel in the UI thread, so send a cancel request
-  // to stop the network requests in net IO thread.
-  void OnCancelSaveRequest(int render_process_id, int request_id);
   // Notifies SavePackage that the whole page saving job is finished.
   void OnFinishSavePageJob(int render_process_id, int render_view_id);
 
   // Notifications sent from the UI thread and run on the file thread.
 
   // Deletes a specified file on the file thread.
   void OnDeleteDirectoryOrFile(const FilePath& full_path, bool is_dir);
 
   // Notifications sent from the UI thread and run on the IO thread
 
   // Initiates a request for URL to be saved.
   void OnSaveURL(const GURL& url,
                  const GURL& referrer,
                  int render_process_host_id,
                  int render_view_id,
                  URLRequestContextGetter* request_context_getter);
   // Handler for a notification sent to the IO thread for generating save id.
   void OnRequireSaveJobFromOtherSource(SaveFileCreateInfo* info);
   // Call ResourceDispatcherHost's CancelRequest method to execute cancel
   // action in the IO thread.
   void ExecuteCancelSaveRequest(int render_process_id, int request_id);
 
   // Unique ID for the next SaveFile object.
   int next_id_;
 
   // A map of all saving jobs by using save id.
   typedef base::hash_map<int, SaveFile*> SaveFileMap;
   SaveFileMap save_file_map_;
 
-  // Message loop that the SavePackages live on.
-  MessageLoop* ui_loop_;
-
-  // We cache the IO loop, we will use it to request resources from network.
-  MessageLoop* io_loop_;
-
-  // We cache the file loop, we will use it to do real file operation.
-  // We guarantee that we won't access them incorrectly during the shutdown
-  // process
-  MessageLoop* file_loop_;
-
   ResourceDispatcherHost* resource_dispatcher_host_;
 
   // Tracks which SavePackage to send data to, called only on UI thread.
   // SavePackageMap maps save IDs to their SavePackage.
   typedef base::hash_map<int, SavePackage*> SavePackageMap;
   SavePackageMap packages_;
 
   // There is a gap between after calling SaveURL() and before calling
   // StartSave(). In this gap, each request does not have save id for tracking.
   // But sometimes users might want to stop saving job or ResourceDispatcherHost
   // calls SaveFinished with save id -1 for network error. We name the requests
   // as starting requests. For tracking those starting requests, we need to
   // have some data structure.
   // First we use a hashmap to map the request URL to SavePackage, then we
   // use a hashmap to map the tab id (we actually use render_process_id) to the
   // hashmap since it is possible to save same URL in different tab at
   // same time.
   typedef base::hash_map<std::string, SavePackage*> StartingRequestsMap;
   typedef base::hash_map<int, StartingRequestsMap> TabToStartingRequestsMap;
   TabToStartingRequestsMap tab_starting_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(SaveFileManager);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_SAVE_FILE_MANAGER_H__