Created an interface for DownloadFile, for use in unit tests.

content/browser/download/save_file_manager.cc

 // Copyright (c) 2011 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 "build/build_config.h"
 
 #include "content/browser/download/save_file_manager.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 202 matching lines @@
 void SaveFileManager::StartSave(SaveFileCreateInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(info);
   SaveFile* save_file = new SaveFile(info);
 
   // TODO(phajdan.jr): We should check the return value and handle errors here.
   save_file->Initialize(false);  // No need to calculate hash.
 
   DCHECK(!LookupSaveFile(info->save_id));
   save_file_map_[info->save_id] = save_file;
-  info->path = save_file->full_path();
+  info->path = save_file->FullPath();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&SaveFileManager::OnStartSave, this, info));
 }
 
 // We do forward an update to the UI thread here, since we do not use timer to
 // update the UI. If the user has canceled the saving action (in the UI
 // thread). We may receive a few more updates before the IO thread gets the
 // cancel message. We just delete the data since the SaveFile has been deleted.
 void SaveFileManager::UpdateSaveProgress(int save_id,
                                          net::IOBuffer* data,
                                          int data_len) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   SaveFile* save_file = LookupSaveFile(save_id);
   if (save_file) {
     net::Error write_success =
         save_file->AppendDataToFile(data->data(), data_len);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&SaveFileManager::OnUpdateSaveProgress,
                    this,
                    save_file->save_id(),
-                   save_file->bytes_so_far(),
+                   save_file->BytesSoFar(),
                    write_success == net::OK));
   }
 }
 
 // The IO thread will call this when saving is completed or it got error when
 // fetching data. In the former case, we forward the message to OnSaveFinished
 // in UI thread. In the latter case, the save ID will be -1, which means the
 // saving action did not even start, so we need to call OnErrorFinished in UI
 // thread, which will use the save URL to find corresponding request record and
 // delete it.
 void SaveFileManager::SaveFinished(int save_id,
                                    const GURL& save_url,
                                    int render_process_id,
                                    bool is_success) {
   VLOG(20) << " " << __FUNCTION__ << "()"
            << " save_id = " << save_id
            << " save_url = \"" << save_url.spec() << "\""
            << " is_success = " << is_success;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   SaveFileMap::iterator it = save_file_map_.find(save_id);
   if (it != save_file_map_.end()) {
     SaveFile* save_file = it->second;
   VLOG(20) << " " << __FUNCTION__ << "()"
            << " save_file = " << save_file->DebugString();
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&SaveFileManager::OnSaveFinished, this, save_id,
-            save_file->bytes_so_far(), is_success));
+            save_file->BytesSoFar(), is_success));
 
     save_file->Finish();
     save_file->Detach();
   } else if (save_id == -1) {
     // Before saving started, we got error. We still call finish process.
     DCHECK(!save_url.is_empty());
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&SaveFileManager::OnErrorFinished, this, save_url,
             render_process_id));
@@ skipping 120 matching lines @@
               save_file->render_process_id(), save_file->request_id()));
 
       // UI thread will notify the render process to stop sending data,
       // so in here, we need not to do anything, just close the save file.
       save_file->Cancel();
     } else {
       // If we did not find SaveFile in map, the saving job should either get
       // data from other sources or have finished.
       DCHECK(save_file->save_source() !=
              SaveFileCreateInfo::SAVE_FILE_FROM_NET ||
-             !save_file->in_progress());
+             !save_file->InProgress());
     }
     // Whatever the save file is renamed or not, just delete it.
     save_file_map_.erase(it);
     delete save_file;
   }
 }
 
 // It is possible that SaveItem which has specified save_id has been canceled
 // before this function runs. So if we can not find corresponding SaveFile by
 // using specified save_id, just return.
 void SaveFileManager::SaveLocalFile(const GURL& original_file_url,
                                     int save_id,
                                     int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   SaveFile* save_file = LookupSaveFile(save_id);
   if (!save_file)
     return;
   // If it has finished, just return.
-  if (!save_file->in_progress())
+  if (!save_file->InProgress())
     return;
 
   // Close the save file before the copy operation.
   save_file->Finish();
   save_file->Detach();
 
   DCHECK(original_file_url.SchemeIsFile());
   FilePath file_path;
   net::FileURLToFilePath(original_file_url, &file_path);
   // If we can not get valid file path from original URL, treat it as
   // disk error.
   if (file_path.empty())
     SaveFinished(save_id, original_file_url, render_process_id, false);
 
   // Copy the local file to the temporary file. It will be renamed to its
   // final name later.
-  bool success = file_util::CopyFile(file_path, save_file->full_path());
+  bool success = file_util::CopyFile(file_path, save_file->FullPath());
   if (!success)
-    file_util::Delete(save_file->full_path(), false);
+    file_util::Delete(save_file->FullPath(), false);
   SaveFinished(save_id, original_file_url, render_process_id, success);
 }
 
 void SaveFileManager::OnDeleteDirectoryOrFile(const FilePath& full_path,
                                               bool is_dir) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(!full_path.empty());
 
   file_util::Delete(full_path, is_dir);
 }
 
 void SaveFileManager::RenameAllFiles(
     const FinalNameList& final_names,
     const FilePath& resource_dir,
     int render_process_id,
     int render_view_id,
     int save_package_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (!resource_dir.empty() && !file_util::PathExists(resource_dir))
     file_util::CreateDirectory(resource_dir);
 
   for (FinalNameList::const_iterator i = final_names.begin();
       i != final_names.end(); ++i) {
     SaveFileMap::iterator it = save_file_map_.find(i->first);
     if (it != save_file_map_.end()) {
       SaveFile* save_file = it->second;
-      DCHECK(!save_file->in_progress());
+      DCHECK(!save_file->InProgress());
       save_file->Rename(i->second);
       delete save_file;
       save_file_map_.erase(it);
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&SaveFileManager::OnFinishSavePageJob, this,
           render_process_id, render_view_id, save_package_id));
@@ skipping 13 matching lines @@
 
 void SaveFileManager::RemoveSavedFileFromFileMap(
     const SaveIDList& save_ids) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   for (SaveIDList::const_iterator i = save_ids.begin();
       i != save_ids.end(); ++i) {
     SaveFileMap::iterator it = save_file_map_.find(*i);
     if (it != save_file_map_.end()) {
       SaveFile* save_file = it->second;
-      DCHECK(!save_file->in_progress());
-      file_util::Delete(save_file->full_path(), false);
+      DCHECK(!save_file->InProgress());
+      file_util::Delete(save_file->FullPath(), false);
       delete save_file;
       save_file_map_.erase(it);
     }
   }
 }