1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h" 6 7 #if defined(OS_CHROMEOS) 8 #include "chromeos/dbus/dbus_thread_manager.h" 9 #include "chromeos/dbus/fake_dbus_thread_manager.h" 10 #include "chromeos/dbus/fake_image_burner_client.h" 11 #endif 12 13 namespace extensions { 14 namespace image_writer { 15 16 #if defined(OS_CHROMEOS) 17 namespace { 18 19 class ImageWriterFakeImageBurnerClient 20 : public chromeos::FakeImageBurnerClient { 21 public: 22 ImageWriterFakeImageBurnerClient() {} 23 virtual ~ImageWriterFakeImageBurnerClient() {} 24 25 virtual void SetEventHandlers( 26 const BurnFinishedHandler& burn_finished_handler, 27 const BurnProgressUpdateHandler& burn_progress_update_handler) OVERRIDE { 28 burn_finished_handler_ = burn_finished_handler; 29 burn_progress_update_handler_ = burn_progress_update_handler; 30 } 31 32 virtual void BurnImage(const std::string& from_path, 33 const std::string& to_path, 34 const ErrorCallback& error_callback) OVERRIDE { 35 base::MessageLoop::current()->PostTask(FROM_HERE, 36 base::Bind(burn_progress_update_handler_, to_path, 0, 100)); 37 base::MessageLoop::current()->PostTask(FROM_HERE, 38 base::Bind(burn_progress_update_handler_, to_path, 50, 100)); 39 base::MessageLoop::current()->PostTask(FROM_HERE, 40 base::Bind(burn_progress_update_handler_, to_path, 100, 100)); 41 base::MessageLoop::current()->PostTask(FROM_HERE, 42 base::Bind(burn_finished_handler_, to_path, true, "")); 43 } 44 45 private: 46 BurnFinishedHandler burn_finished_handler_; 47 BurnProgressUpdateHandler burn_progress_update_handler_; 48 }; 49 50 } // namespace 51 #endif 52 53 MockOperationManager::MockOperationManager() : OperationManager(NULL) {} 54 MockOperationManager::MockOperationManager(content::BrowserContext* context) 55 : OperationManager(context) {} 56 MockOperationManager::~MockOperationManager() {} 57 58 #if defined(OS_CHROMEOS) 59 FakeDiskMountManager::FakeDiskMountManager() {} 60 FakeDiskMountManager::~FakeDiskMountManager() {} 61 62 void FakeDiskMountManager::UnmountDeviceRecursively( 63 const std::string& device_path, 64 const UnmountDeviceRecursivelyCallbackType& callback) { 65 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true)); 66 } 67 #endif 68 69 FakeImageWriterClient::FakeImageWriterClient() {} 70 FakeImageWriterClient::~FakeImageWriterClient() {} 71 72 void FakeImageWriterClient::Write(const ProgressCallback& progress_callback, 73 const SuccessCallback& success_callback, 74 const ErrorCallback& error_callback, 75 const base::FilePath& source, 76 const base::FilePath& target) { 77 progress_callback_ = progress_callback; 78 success_callback_ = success_callback; 79 error_callback_ = error_callback; 80 } 81 82 void FakeImageWriterClient::Verify(const ProgressCallback& progress_callback, 83 const SuccessCallback& success_callback, 84 const ErrorCallback& error_callback, 85 const base::FilePath& source, 86 const base::FilePath& target) { 87 progress_callback_ = progress_callback; 88 success_callback_ = success_callback; 89 error_callback_ = error_callback; 90 } 91 92 void FakeImageWriterClient::Cancel(const CancelCallback& cancel_callback) { 93 cancel_callback_ = cancel_callback; 94 } 95 96 void FakeImageWriterClient::Shutdown() { 97 // Clear handlers to not hold any reference to the caller. 98 success_callback_ = base::Closure(); 99 progress_callback_ = base::Callback<void(int64)>(); 100 error_callback_ = base::Callback<void(const std::string&)>(); 101 cancel_callback_ = base::Closure(); 102 } 103 104 void FakeImageWriterClient::Progress(int64 progress) { 105 progress_callback_.Run(progress); 106 } 107 108 void FakeImageWriterClient::Success() { success_callback_.Run(); } 109 110 void FakeImageWriterClient::Error(const std::string& message) { 111 error_callback_.Run(message); 112 } 113 114 void FakeImageWriterClient::Cancel() { cancel_callback_.Run(); } 115 116 scoped_refptr<FakeImageWriterClient> FakeImageWriterClient::Create() { 117 return scoped_refptr<FakeImageWriterClient>(new FakeImageWriterClient()); 118 } 119 120 ImageWriterUnitTestBase::ImageWriterUnitTestBase() 121 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} 122 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {} 123 124 void ImageWriterUnitTestBase::SetUp() { 125 testing::Test::SetUp(); 126 127 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 128 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), 129 &test_image_path_)); 130 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), 131 &test_device_path_)); 132 133 ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize)); 134 ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize)); 135 136 #if defined(OS_CHROMEOS) 137 if (!chromeos::DBusThreadManager::IsInitialized()) { 138 chromeos::FakeDBusThreadManager* fake_dbus_thread_manager = 139 new chromeos::FakeDBusThreadManager; 140 scoped_ptr<chromeos::ImageBurnerClient> 141 image_burner_fake(new ImageWriterFakeImageBurnerClient()); 142 fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass()); 143 chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager); 144 } 145 FakeDiskMountManager* disk_manager = new FakeDiskMountManager(); 146 chromeos::disks::DiskMountManager::InitializeForTesting(disk_manager); 147 148 // Adds a disk entry for test_device_path_ with the same device and file path. 149 disk_manager->CreateDiskEntryForMountDevice( 150 chromeos::disks::DiskMountManager::MountPointInfo( 151 test_device_path_.value(), 152 "/dummy/mount", 153 chromeos::MOUNT_TYPE_DEVICE, 154 chromeos::disks::MOUNT_CONDITION_NONE), 155 "device_id", 156 "device_label", 157 "Vendor", 158 "Product", 159 chromeos::DEVICE_TYPE_USB, 160 kTestFileSize, 161 true, 162 true, 163 false); 164 disk_manager->SetupDefaultReplies(); 165 #endif 166 } 167 168 void ImageWriterUnitTestBase::TearDown() { 169 #if defined(OS_CHROMEOS) 170 chromeos::DBusThreadManager::Shutdown(); 171 chromeos::disks::DiskMountManager::Shutdown(); 172 #endif 173 } 174 175 bool ImageWriterUnitTestBase::ImageWrittenToDevice( 176 const base::FilePath& image_path, 177 const base::FilePath& device_path) { 178 scoped_ptr<char[]> image_buffer(new char[kTestFileSize]); 179 scoped_ptr<char[]> device_buffer(new char[kTestFileSize]); 180 181 int image_bytes_read = 182 ReadFile(image_path, image_buffer.get(), kTestFileSize); 183 184 if (image_bytes_read < 0) 185 return false; 186 187 int device_bytes_read = 188 ReadFile(device_path, device_buffer.get(), kTestFileSize); 189 190 if (image_bytes_read != device_bytes_read) 191 return false; 192 193 return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0; 194 } 195 196 bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file, 197 const int pattern, 198 const int length) { 199 scoped_ptr<char[]> buffer(new char[length]); 200 memset(buffer.get(), pattern, length); 201 202 return base::WriteFile(file, buffer.get(), length) == length; 203 } 204 205 } // namespace image_writer 206 } // namespace extensions 207
