src/chrome/browser/extensions/api/image_writer_private/test_utils.cc

   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   if (!write_callback_.is_null())
  82     write_callback_.Run();
  83 }
  84
  85 void FakeImageWriterClient::Verify(const ProgressCallback& progress_callback,
  86                                    const SuccessCallback& success_callback,
  87                                    const ErrorCallback& error_callback,
  88                                    const base::FilePath& source,
  89                                    const base::FilePath& target) {
  90   progress_callback_ = progress_callback;
  91   success_callback_ = success_callback;
  92   error_callback_ = error_callback;
  93
  94   if (!verify_callback_.is_null())
  95     verify_callback_.Run();
  96 }
  97
  98 void FakeImageWriterClient::Cancel(const CancelCallback& cancel_callback) {
  99   cancel_callback_ = cancel_callback;
 100 }
 101
 102 void FakeImageWriterClient::Shutdown() {
 103   // Clear handlers to not hold any reference to the caller.
 104   success_callback_.Reset();
 105   progress_callback_.Reset();
 106   error_callback_.Reset();
 107   cancel_callback_.Reset();
 108
 109   write_callback_.Reset();
 110   verify_callback_.Reset();
 111 }
 112
 113 void FakeImageWriterClient::SetWriteCallback(
 114     const base::Closure& write_callback) {
 115   write_callback_ = write_callback;
 116 }
 117
 118 void FakeImageWriterClient::SetVerifyCallback(
 119     const base::Closure& verify_callback) {
 120   verify_callback_ = verify_callback;
 121 }
 122
 123 void FakeImageWriterClient::Progress(int64 progress) {
 124   if (!progress_callback_.is_null())
 125     progress_callback_.Run(progress);
 126 }
 127
 128 void FakeImageWriterClient::Success() {
 129   if (!success_callback_.is_null())
 130     success_callback_.Run();
 131 }
 132
 133 void FakeImageWriterClient::Error(const std::string& message) {
 134   if (!error_callback_.is_null())
 135     error_callback_.Run(message);
 136 }
 137
 138 void FakeImageWriterClient::Cancel() {
 139   if (!cancel_callback_.is_null())
 140     cancel_callback_.Run();
 141 }
 142
 143 ImageWriterTestUtils::ImageWriterTestUtils() {
 144 }
 145 ImageWriterTestUtils::~ImageWriterTestUtils() {
 146 }
 147
 148 void ImageWriterTestUtils::SetUp() {
 149   SetUp(false);
 150 }
 151
 152 void ImageWriterTestUtils::SetUp(bool is_browser_test) {
 153   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 154   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 155                                              &test_image_path_));
 156   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 157                                              &test_device_path_));
 158
 159   ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize));
 160   ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize));
 161
 162 #if defined(OS_CHROMEOS)
 163   if (!chromeos::DBusThreadManager::IsInitialized()) {
 164     chromeos::FakeDBusThreadManager* fake_dbus_thread_manager =
 165         new chromeos::FakeDBusThreadManager;
 166     fake_dbus_thread_manager->SetFakeClients();
 167     scoped_ptr<chromeos::ImageBurnerClient>
 168         image_burner_fake(new ImageWriterFakeImageBurnerClient());
 169     fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass());
 170
 171     if (is_browser_test) {
 172       chromeos::DBusThreadManager::SetInstanceForTesting(
 173           fake_dbus_thread_manager);
 174     } else {
 175       chromeos::DBusThreadManager::InitializeForTesting(
 176           fake_dbus_thread_manager);
 177     }
 178   }
 179
 180   FakeDiskMountManager* disk_manager = new FakeDiskMountManager();
 181   chromeos::disks::DiskMountManager::InitializeForTesting(disk_manager);
 182
 183   // Adds a disk entry for test_device_path_ with the same device and file path.
 184   disk_manager->CreateDiskEntryForMountDevice(
 185       chromeos::disks::DiskMountManager::MountPointInfo(
 186           test_device_path_.value(),
 187           "/dummy/mount",
 188           chromeos::MOUNT_TYPE_DEVICE,
 189           chromeos::disks::MOUNT_CONDITION_NONE),
 190       "device_id",
 191       "device_label",
 192       "Vendor",
 193       "Product",
 194       chromeos::DEVICE_TYPE_USB,
 195       kTestFileSize,
 196       true,
 197       true,
 198       true,
 199       false);
 200   disk_manager->SetupDefaultReplies();
 201 #else
 202   client_ = new FakeImageWriterClient();
 203   image_writer::Operation::SetUtilityClientForTesting(client_);
 204 #endif
 205 }
 206
 207 void ImageWriterTestUtils::TearDown() {
 208 #if defined(OS_CHROMEOS)
 209   if (chromeos::DBusThreadManager::IsInitialized()) {
 210     chromeos::DBusThreadManager::Shutdown();
 211   }
 212   chromeos::disks::DiskMountManager::Shutdown();
 213 #else
 214   image_writer::Operation::SetUtilityClientForTesting(NULL);
 215   client_->Shutdown();
 216 #endif
 217 }
 218
 219 const base::FilePath& ImageWriterTestUtils::GetTempDir() {
 220   return temp_dir_.path();
 221 }
 222
 223 const base::FilePath& ImageWriterTestUtils::GetImagePath() {
 224   return test_image_path_;
 225 }
 226
 227 const base::FilePath& ImageWriterTestUtils::GetDevicePath() {
 228   return test_device_path_;
 229 }
 230
 231 #if !defined(OS_CHROMEOS)
 232 FakeImageWriterClient* ImageWriterTestUtils::GetUtilityClient() {
 233   return client_.get();
 234 }
 235 #endif
 236
 237 bool ImageWriterTestUtils::ImageWrittenToDevice() {
 238   scoped_ptr<char[]> image_buffer(new char[kTestFileSize]);
 239   scoped_ptr<char[]> device_buffer(new char[kTestFileSize]);
 240
 241   int image_bytes_read =
 242       ReadFile(test_image_path_, image_buffer.get(), kTestFileSize);
 243
 244   if (image_bytes_read < 0)
 245     return false;
 246
 247   int device_bytes_read =
 248       ReadFile(test_device_path_, device_buffer.get(), kTestFileSize);
 249
 250   if (image_bytes_read != device_bytes_read)
 251     return false;
 252
 253   return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0;
 254 }
 255
 256 bool ImageWriterTestUtils::FillFile(const base::FilePath& file,
 257                                     const int pattern,
 258                                     const int length) {
 259   scoped_ptr<char[]> buffer(new char[length]);
 260   memset(buffer.get(), pattern, length);
 261
 262   return base::WriteFile(file, buffer.get(), length) == length;
 263 }
 264
 265 ImageWriterUnitTestBase::ImageWriterUnitTestBase()
 266     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 267 }
 268 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {
 269 }
 270
 271 void ImageWriterUnitTestBase::SetUp() {
 272   testing::Test::SetUp();
 273   test_utils_.SetUp();
 274 }
 275
 276 void ImageWriterUnitTestBase::TearDown() {
 277   testing::Test::TearDown();
 278   test_utils_.TearDown();
 279 }
 280
 281 }  // namespace image_writer
 282 }  // namespace extensions