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_image_burner_client.h"
  10 #endif
  11
  12 namespace extensions {
  13 namespace image_writer {
  14
  15 #if defined(OS_CHROMEOS)
  16 namespace {
  17
  18 class ImageWriterFakeImageBurnerClient
  19     : public chromeos::FakeImageBurnerClient {
  20  public:
  21   ImageWriterFakeImageBurnerClient() {}
  22   ~ImageWriterFakeImageBurnerClient() override {}
  23
  24   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   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
  52 MockOperationManager::MockOperationManager() : OperationManager(NULL) {}
  53 MockOperationManager::MockOperationManager(content::BrowserContext* context)
  54     : OperationManager(context) {}
  55 MockOperationManager::~MockOperationManager() {}
  56
  57 #if defined(OS_CHROMEOS)
  58 FakeDiskMountManager::FakeDiskMountManager() {}
  59 FakeDiskMountManager::~FakeDiskMountManager() {}
  60
  61 void 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
  68 FakeImageWriterClient::FakeImageWriterClient() {}
  69 FakeImageWriterClient::~FakeImageWriterClient() {}
  70
  71 void 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
  84 void 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
  97 void FakeImageWriterClient::Cancel(const CancelCallback& cancel_callback) {
  98   cancel_callback_ = cancel_callback;
  99 }
 100
 101 void 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
 112 void FakeImageWriterClient::SetWriteCallback(
 113     const base::Closure& write_callback) {
 114   write_callback_ = write_callback;
 115 }
 116
 117 void FakeImageWriterClient::SetVerifyCallback(
 118     const base::Closure& verify_callback) {
 119   verify_callback_ = verify_callback;
 120 }
 121
 122 void FakeImageWriterClient::Progress(int64 progress) {
 123   if (!progress_callback_.is_null())
 124     progress_callback_.Run(progress);
 125 }
 126
 127 void FakeImageWriterClient::Success() {
 128   if (!success_callback_.is_null())
 129     success_callback_.Run();
 130 }
 131
 132 void FakeImageWriterClient::Error(const std::string& message) {
 133   if (!error_callback_.is_null())
 134     error_callback_.Run(message);
 135 }
 136
 137 void FakeImageWriterClient::Cancel() {
 138   if (!cancel_callback_.is_null())
 139     cancel_callback_.Run();
 140 }
 141
 142 ImageWriterTestUtils::ImageWriterTestUtils() {
 143 }
 144 ImageWriterTestUtils::~ImageWriterTestUtils() {
 145 }
 146
 147 void ImageWriterTestUtils::SetUp() {
 148   SetUp(false);
 149 }
 150
 151 void 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
 197 void 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
 209 const base::FilePath& ImageWriterTestUtils::GetTempDir() {
 210   return temp_dir_.path();
 211 }
 212
 213 const base::FilePath& ImageWriterTestUtils::GetImagePath() {
 214   return test_image_path_;
 215 }
 216
 217 const base::FilePath& ImageWriterTestUtils::GetDevicePath() {
 218   return test_device_path_;
 219 }
 220
 221 #if !defined(OS_CHROMEOS)
 222 FakeImageWriterClient* ImageWriterTestUtils::GetUtilityClient() {
 223   return client_.get();
 224 }
 225 #endif
 226
 227 bool 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
 246 bool 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
 255 ImageWriterUnitTestBase::ImageWriterUnitTestBase()
 256     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 257 }
 258 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {
 259 }
 260
 261 void ImageWriterUnitTestBase::SetUp() {
 262   testing::Test::SetUp();
 263   test_utils_.SetUp();
 264 }
 265
 266 void ImageWriterUnitTestBase::TearDown() {
 267   testing::Test::TearDown();
 268   test_utils_.TearDown();
 269 }
 270
 271 }  // namespace image_writer
 272 }  // namespace extensions