Add a mock class for DiskMountManagerObserver. disk_mount_manager_observer_unittests will be rewrit…

chromeos/disks/mock_disk_mount_manager_observer.cc

Index: chromeos/disks/mock_disk_mount_manager_observer.cc
diff --git a/chromeos/disks/mock_disk_mount_manager_observer.cc b/chromeos/disks/mock_disk_mount_manager_observer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b0e415085113b4d8d136686ba38f98d8389e2d4c
--- /dev/null
+++ b/chromeos/disks/mock_disk_mount_manager_observer.cc
@@ -0,0 +1,186 @@
+// Copyright (c) 2016 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.
+
+#include "mock_disk_mount_manager_observer.h"
+#include <assert.h>
+#include <sstream>
+#include <string>
+
+namespace chromeos {
+namespace disks {
+
+MockDiskMountManagerObserver::MockDiskMountManagerObserver(
+    const DiskMountManager* manager)
+    : manager_(manager) {}
+
+MockDiskMountManagerObserver::~MockDiskMountManagerObserver() {}
+
+void MockDiskMountManagerObserver::OnDeviceEvent(
+    DiskMountManager::DeviceEvent event,
+    const std::string& device_path) {
+  events_.push_back(
+      ObserverEvent::FromDeviceEvent(DeviceEvent(event, device_path)));
+}
+
+void MockDiskMountManagerObserver::OnDiskEvent(
+    DiskMountManager::DiskEvent event,
+    const DiskMountManager::Disk* disk) {
+  // Take a snapshot (copy) of the Disk object at the time of invocation for
+  // later verification.
+  events_.push_back(ObserverEvent::FromDiskEvent(
+      DiskEvent(event, new DiskMountManager::Disk(*disk))));
+}
+
+void MockDiskMountManagerObserver::OnFormatEvent(
+    DiskMountManager::FormatEvent event,
+    chromeos::FormatError error_code,
+    const std::string& device_path) {
+  events_.push_back(ObserverEvent::FromFormatEvent(
+      FormatEvent(event, error_code, device_path)));
+}
+
+void MockDiskMountManagerObserver::OnMountEvent(
+    DiskMountManager::MountEvent event,
+    chromeos::MountError error_code,
+    const DiskMountManager::MountPointInfo& mount_point) {
+  // Take a snapshot (copy) of a Disk object at the time of invocation.
+  // It can be verified later besides the arguments.
+  events_.push_back(ObserverEvent::FromMountEvent(MountEvent(
+      event, error_code, mount_point,
+      std::shared_ptr<DiskMountManager::Disk>(new DiskMountManager::Disk(
+          *manager_->disks().find(mount_point.source_path)->second)))));
+}
+
+DeviceEvent MockDiskMountManagerObserver::GetDeviceEvent(size_t index) {
+  assert(events_.size() >= index + 1);
+  assert(ObserverEvent::DEVICE_EVENT == events_.at(index).GetType());
+  return events_[index].GetEvent().device;
+}
+
+DiskEvent MockDiskMountManagerObserver::GetDiskEvent(size_t index) {
+  assert(events_.size() >= index + 1);
+  assert(ObserverEvent::DISK_EVENT == events_.at(index).GetType());
+  return events_[index].GetEvent().disk;
+}
+
+FormatEvent MockDiskMountManagerObserver::GetFormatEvent(size_t index) {
+  assert(events_.size() >= index + 1);
+  assert(ObserverEvent::FORMAT_EVENT == events_.at(index).GetType());
+  return events_[index].GetEvent().format;
+}
+
+MountEvent MockDiskMountManagerObserver::GetMountEvent(size_t index) {
+  assert(events_.size() >= index + 1);
+  assert(ObserverEvent::MOUNT_EVENT == events_.at(index).GetType());
+  return events_[index].GetEvent().mount;
+}
+
+ObserverEvent ObserverEvent::FromDeviceEvent(DeviceEvent event) {
+  ObserverEvent result;
+  result.type_ = DEVICE_EVENT;
+  result.event_.device = event;
+  return result;
+}
+
+ObserverEvent ObserverEvent::FromDiskEvent(DiskEvent event) {
+  ObserverEvent result;
+  result.type_ = DISK_EVENT;
+  result.event_.disk = event;
+  return result;
+}
+
+ObserverEvent ObserverEvent::FromFormatEvent(FormatEvent event) {
+  ObserverEvent result;
+  result.type_ = FORMAT_EVENT;
+  result.event_.format = event;
+  return result;
+}
+
+ObserverEvent ObserverEvent::FromMountEvent(MountEvent event) {
+  ObserverEvent result;
+  result.type_ = MOUNT_EVENT;
+  result.event_.mount = event;
+  return result;
+}
+
+MountEvent::MountEvent()
+    : mount_point_("",
+                   "",
+                   MountType::MOUNT_TYPE_INVALID,
+                   MountCondition::MOUNT_CONDITION_NONE) {}
+
+MountEvent::~MountEvent() {}
+
+MountEvent::MountEvent(DiskMountManager::MountEvent event,
+                       chromeos::MountError error_code,
+                       const DiskMountManager::MountPointInfo& mount_point,
+                       std::shared_ptr<DiskMountManager::Disk> disk)
+    : event_(event),
+      error_code_(error_code),
+      mount_point_(mount_point),
+      disk_(disk) {}
+
+MountEvent::MountEvent(const MountEvent& other)
+    : event_(other.event_),
+      error_code_(other.error_code_),
+      mount_point_(other.mount_point_),
+      disk_(other.disk_) {}
+
+ObserverEvent::Event::Event() {}
+
+ObserverEvent::Event::Event(const Event& other)
+    : device(other.device),
+      disk(other.disk),
+      format(other.format),
+      mount(other.mount) {}
+
+std::string DeviceEvent::DebugString() const {
+  std::stringstream ss;
+  ss << "OnDeviceEvent(" << event_ << ", " << device_path_ << ")";
+  return ss.str();
+}
+
+std::string DiskEvent::DebugString() const {
+  std::stringstream ss;
+  ss << "OnDiskEvent(event=" << event_
+     << ", device_path=" << disk_->device_path()
+     << ", mount_path=" << disk_->mount_path() << ")";
+  return ss.str();
+}
+
+std::string FormatEvent::DebugString() const {
+  std::stringstream ss;
+  ss << "OnFormatEvent(" << event_ << ", " << error_code_ << ", "
+     << device_path_ << ")";
+  return ss.str();
+}
+
+std::string MountEvent::DebugString() const {
+  std::stringstream ss;
+  ss << "OnMountEvent(" << event_ << ", " << error_code_ << ", "
+     << mount_point_.source_path << ", " << mount_point_.mount_path << ", "
+     << mount_point_.mount_type << ", " << mount_point_.mount_condition << ")";
+  return ss.str();
+}
+
+std::ostream& operator<<(std::ostream& stream,
+                         const DeviceEvent& device_event) {
+  return stream << device_event.DebugString();
+}
+
+std::ostream& operator<<(std::ostream& stream, const DiskEvent& disk_event) {
+  return stream << disk_event.DebugString();
+}
+
+std::ostream& operator<<(std::ostream& stream,
+                         const FormatEvent& format_event) {
+  return stream << format_event.DebugString();
+}
+
+std::ostream& operator<<(std::ostream& stream, const MountEvent& mount_event) {
+  return stream << mount_event.DebugString();
+}
+
+}  // namespace disks
+}  // namespace chromeos