Test file errors in downloads.

content/test/test_file_error_injector.h

Index: content/test/test_file_error_injector.h
diff --git a/content/test/test_file_error_injector.h b/content/test/test_file_error_injector.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5f4978c2c64cf04a10a98674b10a14dcb0c331d
--- /dev/null
+++ b/content/test/test_file_error_injector.h
@@ -0,0 +1,148 @@
+// 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_TEST_TEST_FILE_ERROR_INJECTOR_H_
+#define CONTENT_TEST_TEST_FILE_ERROR_INJECTOR_H_
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/net_errors.h"
+
+class GURL;
+
+namespace content {
+
+class DownloadId;
+class DownloadFileWithErrorsFactory;
+
+// 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();
+//
+// 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> {
+ public:
+  enum FileOperationCode {
+    FILE_OPERATION_INITIALIZE,
+    FILE_OPERATION_WRITE,
+    FILE_OPERATION_RENAME
+  };
+
+  // Structure that encapsulates the information needed to inject a file error.
+  struct FileErrorInfo {
+    std::string url;  // Full URL of the download.  Identifies the download.
+    FileOperationCode code;  // Operation to affect.
+    int operation_instance;  // 0-based count of operation calls, for each code.
+    net::Error net_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();
+
+  // 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 content::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, content::DownloadId> FileMap;
+
+  TestFileErrorInjector();
+
+  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, content::DownloadId id);
+  void RecordDownloadFileDestruction(const GURL& url);
+
+  // These run on the UI thread.
+  void DownloadFileCreated(GURL url, content::DownloadId id);
+  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_;
+
+  // Keep track of found DownloadFiles.
+  FileMap found_files_;
+
+  // The factory we created.  May outlive this class.
+  DownloadFileWithErrorsFactory* created_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestFileErrorInjector);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_TEST_TEST_FILE_ERROR_INJECTOR_H_