| // 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_ |