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_image_burner_client.h" 10#endif 11 12namespace extensions { 13namespace image_writer { 14 15#if defined(OS_CHROMEOS) 16namespace { 17 18class ImageWriterFakeImageBurnerClient 19 : public chromeos::FakeImageBurnerClient { 20 public: 21 ImageWriterFakeImageBurnerClient() {} 22 virtual ~ImageWriterFakeImageBurnerClient() {} 23 24 virtual void SetEventHandlers( 25 const BurnFinishedHandler& burn_finished_handler, 26 const BurnProgressUpdateHandler& burn_progress_update_handler) OVERRIDE { 27 burn_finished_handler_ = burn_finished_handler; 28 burn_progress_update_handler_ = burn_progress_update_handler; 29 } 30 31 virtual void BurnImage(const std::string& from_path, 32 const std::string& to_path, 33 const ErrorCallback& error_callback) OVERRIDE { 34 base::MessageLoop::current()->PostTask(FROM_HERE, 35 base::Bind(burn_progress_update_handler_, to_path, 0, 100)); 36 base::MessageLoop::current()->PostTask(FROM_HERE, 37 base::Bind(burn_progress_update_handler_, to_path, 50, 100)); 38 base::MessageLoop::current()->PostTask(FROM_HERE, 39 base::Bind(burn_progress_update_handler_, to_path, 100, 100)); 40 base::MessageLoop::current()->PostTask(FROM_HERE, 41 base::Bind(burn_finished_handler_, to_path, true, "")); 42 } 43 44 private: 45 BurnFinishedHandler burn_finished_handler_; 46 BurnProgressUpdateHandler burn_progress_update_handler_; 47}; 48 49} // namespace 50#endif 51 52MockOperationManager::MockOperationManager() : OperationManager(NULL) {} 53MockOperationManager::MockOperationManager(content::BrowserContext* context) 54 : OperationManager(context) {} 55MockOperationManager::~MockOperationManager() {} 56 57#if defined(OS_CHROMEOS) 58FakeDiskMountManager::FakeDiskMountManager() {} 59FakeDiskMountManager::~FakeDiskMountManager() {} 60 61void FakeDiskMountManager::UnmountDeviceRecursively( 62 const std::string& device_path, 63 const UnmountDeviceRecursivelyCallbackType& callback) { 64 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true)); 65} 66#endif 67 68FakeImageWriterClient::FakeImageWriterClient() {} 69FakeImageWriterClient::~FakeImageWriterClient() {} 70 71void FakeImageWriterClient::Write(const ProgressCallback& progress_callback, 72 const SuccessCallback& success_callback, 73 const ErrorCallback& error_callback, 74 const base::FilePath& source, 75 const base::FilePath& target) { 76 progress_callback_ = progress_callback; 77 success_callback_ = success_callback; 78 error_callback_ = error_callback; 79 80 if (!write_callback_.is_null()) 81 write_callback_.Run(); 82} 83 84void FakeImageWriterClient::Verify(const ProgressCallback& progress_callback, 85 const SuccessCallback& success_callback, 86 const ErrorCallback& error_callback, 87 const base::FilePath& source, 88 const base::FilePath& target) { 89 progress_callback_ = progress_callback; 90 success_callback_ = success_callback; 91 error_callback_ = error_callback; 92 93 if (!verify_callback_.is_null()) 94 verify_callback_.Run(); 95} 96 97void FakeImageWriterClient::Cancel(const CancelCallback& cancel_callback) { 98 cancel_callback_ = cancel_callback; 99} 100 101void FakeImageWriterClient::Shutdown() { 102 // Clear handlers to not hold any reference to the caller. 103 success_callback_.Reset(); 104 progress_callback_.Reset(); 105 error_callback_.Reset(); 106 cancel_callback_.Reset(); 107 108 write_callback_.Reset(); 109 verify_callback_.Reset(); 110} 111 112void FakeImageWriterClient::SetWriteCallback( 113 const base::Closure& write_callback) { 114 write_callback_ = write_callback; 115} 116 117void FakeImageWriterClient::SetVerifyCallback( 118 const base::Closure& verify_callback) { 119 verify_callback_ = verify_callback; 120} 121 122void FakeImageWriterClient::Progress(int64 progress) { 123 if (!progress_callback_.is_null()) 124 progress_callback_.Run(progress); 125} 126 127void FakeImageWriterClient::Success() { 128 if (!success_callback_.is_null()) 129 success_callback_.Run(); 130} 131 132void FakeImageWriterClient::Error(const std::string& message) { 133 if (!error_callback_.is_null()) 134 error_callback_.Run(message); 135} 136 137void FakeImageWriterClient::Cancel() { 138 if (!cancel_callback_.is_null()) 139 cancel_callback_.Run(); 140} 141 142ImageWriterTestUtils::ImageWriterTestUtils() { 143} 144ImageWriterTestUtils::~ImageWriterTestUtils() { 145} 146 147void ImageWriterTestUtils::SetUp() { 148 SetUp(false); 149} 150 151void ImageWriterTestUtils::SetUp(bool is_browser_test) { 152 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 153 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), 154 &test_image_path_)); 155 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), 156 &test_device_path_)); 157 158 ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize)); 159 ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize)); 160 161#if defined(OS_CHROMEOS) 162 if (!chromeos::DBusThreadManager::IsInitialized()) { 163 scoped_ptr<chromeos::DBusThreadManagerSetter> dbus_setter = 164 chromeos::DBusThreadManager::GetSetterForTesting(); 165 scoped_ptr<chromeos::ImageBurnerClient> 166 image_burner_fake(new ImageWriterFakeImageBurnerClient()); 167 dbus_setter->SetImageBurnerClient(image_burner_fake.Pass()); 168 } 169 170 FakeDiskMountManager* disk_manager = new FakeDiskMountManager(); 171 chromeos::disks::DiskMountManager::InitializeForTesting(disk_manager); 172 173 // Adds a disk entry for test_device_path_ with the same device and file path. 174 disk_manager->CreateDiskEntryForMountDevice( 175 chromeos::disks::DiskMountManager::MountPointInfo( 176 test_device_path_.value(), 177 "/dummy/mount", 178 chromeos::MOUNT_TYPE_DEVICE, 179 chromeos::disks::MOUNT_CONDITION_NONE), 180 "device_id", 181 "device_label", 182 "Vendor", 183 "Product", 184 chromeos::DEVICE_TYPE_USB, 185 kTestFileSize, 186 true, 187 true, 188 true, 189 false); 190 disk_manager->SetupDefaultReplies(); 191#else 192 client_ = new FakeImageWriterClient(); 193 image_writer::Operation::SetUtilityClientForTesting(client_); 194#endif 195} 196 197void ImageWriterTestUtils::TearDown() { 198#if defined(OS_CHROMEOS) 199 if (chromeos::DBusThreadManager::IsInitialized()) { 200 chromeos::DBusThreadManager::Shutdown(); 201 } 202 chromeos::disks::DiskMountManager::Shutdown(); 203#else 204 image_writer::Operation::SetUtilityClientForTesting(NULL); 205 client_->Shutdown(); 206#endif 207} 208 209const base::FilePath& ImageWriterTestUtils::GetTempDir() { 210 return temp_dir_.path(); 211} 212 213const base::FilePath& ImageWriterTestUtils::GetImagePath() { 214 return test_image_path_; 215} 216 217const base::FilePath& ImageWriterTestUtils::GetDevicePath() { 218 return test_device_path_; 219} 220 221#if !defined(OS_CHROMEOS) 222FakeImageWriterClient* ImageWriterTestUtils::GetUtilityClient() { 223 return client_.get(); 224} 225#endif 226 227bool ImageWriterTestUtils::ImageWrittenToDevice() { 228 scoped_ptr<char[]> image_buffer(new char[kTestFileSize]); 229 scoped_ptr<char[]> device_buffer(new char[kTestFileSize]); 230 231 int image_bytes_read = 232 ReadFile(test_image_path_, image_buffer.get(), kTestFileSize); 233 234 if (image_bytes_read < 0) 235 return false; 236 237 int device_bytes_read = 238 ReadFile(test_device_path_, device_buffer.get(), kTestFileSize); 239 240 if (image_bytes_read != device_bytes_read) 241 return false; 242 243 return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0; 244} 245 246bool ImageWriterTestUtils::FillFile(const base::FilePath& file, 247 const int pattern, 248 const int length) { 249 scoped_ptr<char[]> buffer(new char[length]); 250 memset(buffer.get(), pattern, length); 251 252 return base::WriteFile(file, buffer.get(), length) == length; 253} 254 255ImageWriterUnitTestBase::ImageWriterUnitTestBase() 256 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) { 257} 258ImageWriterUnitTestBase::~ImageWriterUnitTestBase() { 259} 260 261void ImageWriterUnitTestBase::SetUp() { 262 testing::Test::SetUp(); 263 test_utils_.SetUp(); 264} 265 266void ImageWriterUnitTestBase::TearDown() { 267 testing::Test::TearDown(); 268 test_utils_.TearDown(); 269} 270 271} // namespace image_writer 272} // namespace extensions 273