Use stub impl when libcros fails to load

chrome/browser/chromeos/cros/mount_library.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/mount_library.h"
 
 #include <set>
 #include <vector>
 
 #include "base/message_loop.h"
@@ skipping 83 matching lines @@
 
 MountLibrary::Disk::~Disk() {}
 
 class MountLibcrosProxyImpl : public MountLibcrosProxy {
  public:
   virtual void CallMountPath(const char* source_path,
                              MountType type,
                              const MountPathOptions& options,
                              MountCompletedMonitor callback,
                              void* object) OVERRIDE {
-    MountSourcePath(source_path, type, options, callback, object);
+    chromeos::MountSourcePath(source_path, type, options, callback, object);
   }
 
   virtual void CallUnmountPath(const char* path,
                                UnmountRequestCallback callback,
                                void* object) OVERRIDE {
-    UnmountMountPoint(path, callback, object);
+    chromeos::UnmountMountPoint(path, callback, object);
   }
 
   virtual void CallRequestMountInfo(RequestMountInfoCallback callback,
                                     void* object) OVERRIDE {
-    RequestMountInfo(callback, object);
+    chromeos::RequestMountInfo(callback, object);
   }
 
   virtual void CallFormatDevice(const char* file_path,
                                 const char* filesystem,
                                 FormatRequestCallback callback,
                                 void* object) OVERRIDE {
-    FormatDevice(file_path, filesystem, callback, object);
+    chromeos::FormatDevice(file_path, filesystem, callback, object);
   }
 
   virtual void CallGetDiskProperties(const char* device_path,
                                      GetDiskPropertiesCallback callback,
                                      void* object) OVERRIDE {
-    GetDiskProperties(device_path, callback, object);
+    chromeos::GetDiskProperties(device_path, callback, object);
   }
 
-  virtual MountEventConnection MonitorCrosDisks(MountEventMonitor monitor,
+  virtual MountEventConnection MonitorCrosDisks(
+      MountEventMonitor monitor,
       MountCompletedMonitor mount_completed_monitor,
       void* object) OVERRIDE {
-    return MonitorAllMountEvents(monitor, mount_completed_monitor, object);
+    return chromeos::MonitorAllMountEvents(
+        monitor, mount_completed_monitor, object);
   }
 
-  virtual void DisconnectCrosDisksMonitorIfSet(MountEventConnection conn)
-      OVERRIDE {
+  virtual void DisconnectCrosDisksMonitorIfSet(
+      MountEventConnection conn) OVERRIDE {
     if (conn)
-      DisconnectMountEventMonitor(conn);
+      chromeos::DisconnectMountEventMonitor(conn);
   }
 };
 
 class MountLibraryImpl : public MountLibrary {
 
   struct UnmountDeviceRecursiveCallbackData {
     MountLibraryImpl* const object;
     void* user_data;
     UnmountDeviceRecursiveCallbackType callback;
     size_t pending_callbacks_count;
     bool success;
 
     UnmountDeviceRecursiveCallbackData(MountLibraryImpl* const o, void* ud,
         UnmountDeviceRecursiveCallbackType cb, int count)
          : object(o),
           user_data(ud),
           callback(cb),
           pending_callbacks_count(count),
           success(true) {
     }
   };
 
  public:
   MountLibraryImpl() : libcros_proxy_(new MountLibcrosProxyImpl()),
                        mount_status_connection_(NULL) {
-    if (CrosLibrary::Get()->EnsureLoaded())
-      Init();
-    else
-      LOG(ERROR) << kLibraryNotLoaded;
   }
 
   virtual ~MountLibraryImpl() {
       libcros_proxy_->DisconnectCrosDisksMonitorIfSet(
           mount_status_connection_);
   }
 
   // MountLibrary overrides.
+  virtual void Init() OVERRIDE {
+    DCHECK(CrosLibrary::Get()->libcros_loaded());
+    // Getting the monitor status so that the daemon starts up.
+    mount_status_connection_ = libcros_proxy_->MonitorCrosDisks(
+        &MonitorMountEventsHandler, &MountCompletedHandler, this);
+  }
+
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
   virtual void MountPath(const char* source_path,
                          MountType type,
                          const MountPathOptions& options) OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (!CrosLibrary::Get()->EnsureLoaded()) {
-      OnMountCompleted(MOUNT_ERROR_LIBRARY_NOT_LOADED,
-                       MountPointInfo(source_path,
-                                      NULL,
-                                      type,
-                                      MOUNT_CONDITION_NONE));
-      return;
-    }
     libcros_proxy_->CallMountPath(source_path, type, options,
                                   &MountCompletedHandler, this);
   }
 
   virtual void UnmountPath(const char* mount_path) OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (!CrosLibrary::Get()->EnsureLoaded()) {
-      OnUnmountPath(mount_path,
-                    MOUNT_METHOD_ERROR_LOCAL,
-                    kLibraryNotLoaded);
-      return;
-    }
-
     libcros_proxy_->CallUnmountPath(mount_path, &UnmountMountPointCallback,
                                     this);
   }
 
   virtual void FormatUnmountedDevice(const char* file_path) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (!CrosLibrary::Get()->EnsureLoaded()) {
-      OnFormatDevice(file_path,
-                     false,
-                     MOUNT_METHOD_ERROR_LOCAL,
-                     kLibraryNotLoaded);
-      return;
-    }
     for (MountLibrary::DiskMap::iterator it = disks_.begin();
         it != disks_.end(); ++it) {
       if (it->second->file_path().compare(file_path) == 0 &&
           !it->second->mount_path().empty()) {
         OnFormatDevice(file_path,
                        false,
                        MOUNT_METHOD_ERROR_LOCAL,
                        "Device is still mounted.");
         return;
       }
@@ skipping 33 matching lines @@
     UnmountPath(disk->mount_path().c_str());
   }
 
   virtual void UnmountDeviceRecursive(const char* device_path,
       UnmountDeviceRecursiveCallbackType callback, void* user_data)
       OVERRIDE {
     bool success = true;
     const char* error_message = NULL;
     std::vector<const char*> devices_to_unmount;
 
-    if (!CrosLibrary::Get()->EnsureLoaded()) {
-      success = false;
-      error_message = kLibraryNotLoaded;
-    } else {
-      // Get list of all devices to unmount.
-      int device_path_len = strlen(device_path);
-      for (DiskMap::iterator it = disks_.begin(); it != disks_.end(); ++it) {
-        if (!it->second->mount_path().empty() &&
-            strncmp(device_path, it->second->device_path().c_str(),
-                    device_path_len) == 0) {
-          devices_to_unmount.push_back(it->second->mount_path().c_str());
-        }
-      }
-
-      // We should detect at least original device.
-      if (devices_to_unmount.size() == 0) {
-        if (disks_.find(device_path) == disks_.end()) {
-          success = false;
-          error_message = kDeviceNotFound;
-        } else {
-          // Nothing to unmount.
-          callback(user_data, true);
-          return;
-        }
+    // Get list of all devices to unmount.
+    int device_path_len = strlen(device_path);
+    for (DiskMap::iterator it = disks_.begin(); it != disks_.end(); ++it) {
+      if (!it->second->mount_path().empty() &&
+          strncmp(device_path, it->second->device_path().c_str(),
+                  device_path_len) == 0) {
+        devices_to_unmount.push_back(it->second->mount_path().c_str());
       }
     }
 
+    // We should detect at least original device.
+    if (devices_to_unmount.size() == 0) {
+      if (disks_.find(device_path) == disks_.end()) {
+        success = false;
+        error_message = kDeviceNotFound;
+      } else {
+        // Nothing to unmount.
+        callback(user_data, true);
+        return;
+      }
+    }
+
     if (success) {
       // We will send the same callback data object to all Unmount calls and use
       // it to syncronize callbacks.
       UnmountDeviceRecursiveCallbackData*
           cb_data = new UnmountDeviceRecursiveCallbackData(this, user_data,
           callback, devices_to_unmount.size());
       for (std::vector<const char*>::iterator it = devices_to_unmount.begin();
            it != devices_to_unmount.end();
            ++it) {
         libcros_proxy_->CallUnmountPath(*it, &UnmountDeviceRecursiveCallback,
                                         cb_data);
       }
     } else {
       LOG(WARNING) << "Unmount recursive request failed for device "
                    << device_path << ", with error: " << error_message;
       callback(user_data, false);
     }
   }
 
   virtual void RequestMountInfoRefresh() OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (!CrosLibrary::Get()->EnsureLoaded()) {
-      OnRequestMountInfo(NULL,
-                         0,
-                         MOUNT_METHOD_ERROR_LOCAL,
-                         kLibraryNotLoaded);
-      return;
-    }
     libcros_proxy_->CallRequestMountInfo(RequestMountInfoCallback, this);
   }
 
   const DiskMap& disks() const OVERRIDE { return disks_; }
   const MountPointMap& mount_points() const OVERRIDE { return mount_points_; }
 
   virtual void SetLibcrosProxy(MountLibcrosProxy* proxy) OVERRIDE {
     libcros_proxy_->DisconnectCrosDisksMonitorIfSet(mount_status_connection_);
     libcros_proxy_.reset(proxy);
     mount_status_connection_ = libcros_proxy_->MonitorCrosDisks(
@@ skipping 373 matching lines @@
         type = MOUNT_FORMATTING_FINISHED;
         break;
       }
       default: {
         return;
       }
     }
     FireDeviceStatusUpdate(type, std::string(device_path));
   }
 
-  void Init() {
-    // Getting the monitor status so that the daemon starts up.
-    mount_status_connection_ = libcros_proxy_->MonitorCrosDisks(
-        &MonitorMountEventsHandler, &MountCompletedHandler, this);
-  }
-
   void FireDiskStatusUpdate(MountLibraryEventType evt,
                             const Disk* disk) {
     // Make sure we run on UI thread.
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     FOR_EACH_OBSERVER(
         Observer, observers_, DiskChanged(evt, disk));
   }
 
   void FireDeviceStatusUpdate(MountLibraryEventType evt,
                               const std::string& device_path) {
@@ skipping 65 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MountLibraryImpl);
 };
 
 class MountLibraryStubImpl : public MountLibrary {
  public:
   MountLibraryStubImpl() {}
   virtual ~MountLibraryStubImpl() {}
 
   // MountLibrary overrides.
+  virtual void Init() OVERRIDE {}
   virtual void AddObserver(Observer* observer) OVERRIDE {}
   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
   virtual const DiskMap& disks() const OVERRIDE { return disks_; }
   virtual const MountPointMap& mount_points() const OVERRIDE {
     return mount_points_;
   }
   virtual void RequestMountInfoRefresh() OVERRIDE {}
   virtual void MountPath(const char* source_path, MountType type,
                          const MountPathOptions& options) OVERRIDE {}
   virtual void UnmountPath(const char* mount_path) OVERRIDE {}
   virtual void FormatUnmountedDevice(const char* device_path) OVERRIDE {}
   virtual void FormatMountedDevice(const char* mount_path) OVERRIDE {}
   virtual void UnmountDeviceRecursive(const char* device_path,
       UnmountDeviceRecursiveCallbackType callback, void* user_data)
       OVERRIDE {}
  private:
   // The list of disks found.
   DiskMap disks_;
   MountPointMap mount_points_;
 
   DISALLOW_COPY_AND_ASSIGN(MountLibraryStubImpl);
 };
 
 // static
 MountLibrary* MountLibrary::GetImpl(bool stub) {
+  MountLibrary* impl;
   if (stub)
-    return new MountLibraryStubImpl();
+    impl = new MountLibraryStubImpl();
   else
-    return new MountLibraryImpl();
+    impl = new MountLibraryImpl();
+  impl->Init();
+  return impl;
 }
 
 }  // namespace chromeos
-
-// Allows InvokeLater without adding refcounting. This class is a Singleton and
-// won't be deleted until it's last InvokeLater is run.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::MountLibraryImpl);
-