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

content/browser/download/download_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 "content/browser/download/download_file_manager.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/download/base_file.h"
 #include "content/browser/download/download_buffer.h"
 #include "content/browser/download/download_create_info.h"
-#include "content/browser/download/download_file.h"
+#include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_manager.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 
@@ skipping 31 matching lines @@
 void DownloadFileManager::CreateDownloadFile(
     DownloadCreateInfo* info, const DownloadRequestHandle& request_handle,
     DownloadManager* download_manager, bool get_hash) {
   DCHECK(info);
   VLOG(20) << __FUNCTION__ << "()" << " info = " << info->DebugString();
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Life of |info| ends here. No more references to it after this method.
   scoped_ptr<DownloadCreateInfo> infop(info);
 
-  scoped_ptr<DownloadFile>
-      download_file(new DownloadFile(info,
-                                     new DownloadRequestHandle(request_handle),
-                                     download_manager));
+  scoped_ptr<DownloadFile> download_file(
+      new DownloadFileImpl(info,
+                           new DownloadRequestHandle(request_handle),
+                           download_manager));
   if (net::OK != download_file->Initialize(get_hash)) {
     request_handle.CancelRequest();
     return;
   }
 
   DCHECK(GetDownloadFile(info->download_id) == NULL);
   downloads_[info->download_id] = download_file.release();
 
   // The file is now ready, we can un-pause the request and start saving data.
   request_handle.ResumeRequest();
 
   StartUpdateTimer();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadManager::StartDownload, download_manager,
                  info->download_id.local()));
 }
 
-DownloadFile* DownloadFileManager::GetDownloadFile(DownloadId global_id) {
+DownloadFile* DownloadFileManager::GetDownloadFile(
+    DownloadId global_id) {
   DownloadFileMap::iterator it = downloads_.find(global_id);
   return it == downloads_.end() ? NULL : it->second;
 }
 
 void DownloadFileManager::StartUpdateTimer() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!update_timer_.IsRunning()) {
     update_timer_.Start(FROM_HERE,
                         base::TimeDelta::FromMilliseconds(kUpdatePeriodMs),
                         this, &DownloadFileManager::UpdateInProgressDownloads);
   }
 }
 
 void DownloadFileManager::StopUpdateTimer() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   update_timer_.Stop();
 }
 
 void DownloadFileManager::UpdateInProgressDownloads() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   for (DownloadFileMap::iterator i = downloads_.begin();
        i != downloads_.end(); ++i) {
     DownloadId global_id = i->first;
     DownloadFile* download_file = i->second;
     DownloadManager* manager = download_file->GetDownloadManager();
     if (manager) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::Bind(&DownloadManager::UpdateDownload, manager,
-                     global_id.local(), download_file->bytes_so_far()));
+                     global_id.local(), download_file->BytesSoFar()));
     }
   }
 }
 
 void DownloadFileManager::StartDownload(
     DownloadCreateInfo* info, const DownloadRequestHandle& request_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(info);
 
   DownloadManager* manager = request_handle.GetDownloadManager();
@@ skipping 33 matching lines @@
     net::IOBuffer* data = (*contents)[i].first;
     const int data_len = (*contents)[i].second;
     if (!had_error && download_file) {
       net::Error write_result =
           download_file->AppendDataToFile(data->data(), data_len);
       if (write_result != net::OK) {
         // Write failed: interrupt the download.
         DownloadManager* download_manager = download_file->GetDownloadManager();
         had_error = true;
 
-        int64 bytes_downloaded = download_file->bytes_so_far();
+        int64 bytes_downloaded = download_file->BytesSoFar();
         // Calling this here in case we get more data, to avoid
         // processing data after an error.  That could lead to
         // files that are corrupted if the later processing succeeded.
         CancelDownload(global_id);
         download_file = NULL;  // Was deleted in |CancelDownload|.
 
         if (download_manager) {
           BrowserThread::PostTask(
               BrowserThread::UI, FROM_HERE,
               base::Bind(&DownloadManager::OnDownloadInterrupted,
@@ skipping 29 matching lines @@
 
   std::string hash;
   if (!download_file->GetSha256Hash(&hash) || BaseFile::IsEmptySha256Hash(hash))
     hash.clear();
 
   if (reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadManager::OnResponseCompleted,
                    download_manager, global_id.local(),
-                   download_file->bytes_so_far(), hash));
+                   download_file->BytesSoFar(), hash));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadManager::OnDownloadInterrupted,
                    download_manager, global_id.local(),
-                   download_file->bytes_so_far(), reason));
+                   download_file->BytesSoFar(), reason));
   }
   // We need to keep the download around until the UI thread has finalized
   // the name.
 }
 
 // This method will be sent via a user action, or shutdown on the UI thread, and
 // run on the download thread. Since this message has been sent from the UI
 // thread, the download may have already completed and won't exist in our map.
 void DownloadFileManager::CancelDownload(DownloadId global_id) {
   VLOG(20) << __FUNCTION__ << "()" << " id = " << global_id;
@@ skipping 37 matching lines @@
        i != downloads_.end(); ++i) {
     DownloadFile* download_file = i->second;
     if (download_file->GetDownloadManager() == manager) {
       download_file->CancelDownloadRequest();
       to_remove.insert(download_file);
     }
   }
 
   for (std::set<DownloadFile*>::iterator i = to_remove.begin();
        i != to_remove.end(); ++i) {
-    downloads_.erase((*i)->global_id());
+    downloads_.erase((*i)->GlobalId());
     delete *i;
   }
 }
 
 // Actions from the UI thread and run on the download thread
 
 // The DownloadManager in the UI thread has provided an intermediate .crdownload
 // name for the download specified by 'id'. Rename the in progress download.
 //
 // There are 2 possible rename cases where this method can be called:
@@ skipping 99 matching lines @@
     // need to do it here.  The normal path will also update the download
     // history before canceling the request.
     download_file->CancelDownloadRequest();
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadManager::OnDownloadInterrupted,
                  download_manager, global_id.local(),
-                 download_file->bytes_so_far(),
+                 download_file->BytesSoFar(),
                  ConvertNetErrorToInterruptReason(
                      rename_error, DOWNLOAD_INTERRUPT_FROM_DISK)));
 }
 
 void DownloadFileManager::EraseDownload(DownloadId global_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (!ContainsKey(downloads_, global_id))
     return;
 
   DownloadFile* download_file = downloads_[global_id];
 
   VLOG(20) << " " << __FUNCTION__ << "()"
            << " id = " << global_id
            << " download_file = " << download_file->DebugString();
 
   downloads_.erase(global_id);
 
   delete download_file;
 
   if (downloads_.empty())
     StopUpdateTimer();
 }