Replace the DownloadFileManager with direct ownership

content/public/test/test_file_error_injector.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_TEST_TEST_FILE_ERROR_INJECTOR_H_
 #define CONTENT_PUBLIC_TEST_TEST_FILE_ERROR_INJECTOR_H_
 
 #include <map>
+#include <set>
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/ref_counted.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 
+class DownloadManagerImpl;
 class GURL;
 
 namespace content {
 
 class DownloadId;
 class DownloadFileWithErrorsFactory;
+class DownloadManager;
 
 // Test helper for injecting errors into download file operations.
 // All errors for a download must be injected before it starts.
 // This class needs to be |RefCountedThreadSafe| because the implementation
 // is referenced by other classes that live past the time when the user is
 // nominally done with it.  These classes are internal to content/.
 //
 // NOTE: No more than one download with the same URL can be in progress at
 // the same time.  You can have multiple simultaneous downloads as long as the
 // URLs are different, as the URLs are used as keys to get information about
 // the download.
 //
 // Example:
 //
 // FileErrorInfo a = { url1, ... };
 // FileErrorInfo b = { url2, ... };
 //
 // scoped_refptr<TestFileErrorInjector> injector =
-//     TestFileErrorInjector::Create();
+//     TestFileErrorInjector::Create(download_manager);
 //
 // injector->AddError(a);
 // injector->AddError(b);
 // injector->InjectErrors();
 //
 // download_manager->DownloadUrl(url1, ...);
 // download_manager->DownloadUrl(url2, ...);
 // ... wait for downloads to finish or get an injected error ...
 class TestFileErrorInjector
     : public base::RefCountedThreadSafe<TestFileErrorInjector> {
@@ skipping 10 matching lines @@
     FileOperationCode code;  // Operation to affect.
     int operation_instance;  // 0-based count of operation calls, for each code.
     content::DownloadInterruptReason error;  // Error to inject.
   };
 
   typedef std::map<std::string, FileErrorInfo> ErrorMap;
 
   // Creates an instance.  May only be called once.
   // Lives until all callbacks (in the implementation) are complete and the
   // creator goes out of scope.
-  static scoped_refptr<TestFileErrorInjector> Create();
+  // TODO(rdsmith): Allow multiple calls for different download managers.
+  static scoped_refptr<TestFileErrorInjector> Create(
+      scoped_refptr<content::DownloadManager> download_manager);
 
   // Adds an error.
   // Must be called before |InjectErrors()| for a particular download file.
   // It is an error to call |AddError()| more than once for the same file
   // (URL), unless you call |ClearErrors()| in between them.
   bool AddError(const FileErrorInfo& error_info);
 
   // Clears all errors.
   // Only affects files created after the next call to InjectErrors().
   void ClearErrors();
 
   // Injects the errors such that new download files will be affected.
   // The download system must already be initialized before calling this.
   // Multiple calls are allowed, but only useful if the errors have changed.
   // Replaces the injected error list.
   bool InjectErrors();
 
   // Tells how many files are currently open.
   size_t CurrentFileCount() const;
 
   // Tells how many files have ever been open (since construction or the
   // last call to |ClearFoundFiles()|).
   size_t TotalFileCount() const;
 
   // Returns whether or not a file matching |url| has been created.
   bool HadFile(const GURL& url) const;
 
-  // Gets the download ID associated with the file matching |url|.
-  const DownloadId GetId(const GURL& url) const;
-
   // Resets the found file list.
   void ClearFoundFiles();
 
   static std::string DebugString(FileOperationCode code);
 
  private:
   friend class base::RefCountedThreadSafe<TestFileErrorInjector>;
 
-  typedef std::map<GURL, DownloadId> FileMap;
+  typedef std::set<GURL> FileSet;
 
-  TestFileErrorInjector();
+  TestFileErrorInjector(
+      scoped_refptr<content::DownloadManager> download_manager);
 
   virtual ~TestFileErrorInjector();
 
-  void AddFactory(scoped_ptr<DownloadFileWithErrorsFactory> factory);
-
-  void InjectErrorsOnFileThread(ErrorMap map,
-                                DownloadFileWithErrorsFactory* factory);
-
   // Callbacks from the download file, to record lifetimes.
   // These may be called on any thread.
-  void RecordDownloadFileConstruction(const GURL& url, DownloadId id);
+  void RecordDownloadFileConstruction(const GURL& url);
   void RecordDownloadFileDestruction(const GURL& url);
 
   // These run on the UI thread.
-  void DownloadFileCreated(GURL url, DownloadId id);
+  void DownloadFileCreated(GURL url);
   void DestroyingDownloadFile(GURL url);
 
   // All the data is used on the UI thread.
   // Our injected error list, mapped by URL.  One per file.
   ErrorMap injected_errors_;
 
   // Keep track of active DownloadFiles.
-  FileMap files_;
+  FileSet files_;
 
   // Keep track of found DownloadFiles.
-  FileMap found_files_;
+  FileSet found_files_;
 
   // The factory we created.  May outlive this class.
   DownloadFileWithErrorsFactory* created_factory_;
 
+  // The download manager we set the factory on.
+  scoped_refptr<DownloadManagerImpl> download_manager_;
+
   DISALLOW_COPY_AND_ASSIGN(TestFileErrorInjector);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_TEST_TEST_FILE_ERROR_INJECTOR_H_