Adding support to retrieve remaining and total space on disk/file shelf.

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 108 matching lines @@
                                 void* object) OVERRIDE {
     FormatDevice(file_path, filesystem, callback, object);
   }
 
   virtual void CallGetDiskProperties(const char* device_path,
                                      GetDiskPropertiesCallback callback,
                                      void* object) OVERRIDE {
     GetDiskProperties(device_path, callback, object);
   }
 
+  virtual void CallGetSizeStats(const char* mount_path,
+                                GetSizeStatsCallback callback,
+                                void* object) OVERRIDE {
+    GetMountPointSizeStats(mount_path, callback, object);
+  }
+
   virtual MountEventConnection MonitorCrosDisks(MountEventMonitor monitor,
       MountCompletedMonitor mount_completed_monitor,
       void* object) OVERRIDE {
     return MonitorAllMountEvents(monitor, mount_completed_monitor, object);
   }
 
   virtual void DisconnectCrosDisksMonitorIfSet(MountEventConnection conn)
       OVERRIDE {
     if (conn)
       DisconnectMountEventMonitor(conn);
@@ skipping 64 matching lines @@
       OnUnmountPath(mount_path,
                     MOUNT_METHOD_ERROR_LOCAL,
                     kLibraryNotLoaded);
       return;
     }
 
     libcros_proxy_->CallUnmountPath(mount_path, &UnmountMountPointCallback,
                                     this);
   }
 
+  virtual void GetSizeStats(const char* mount_path,
+      CallbackDelegate* callback_delegate) OVERRIDE {
+    CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (!CrosLibrary::Get()->EnsureLoaded()) {
+      GetSizeStatsCallback(callback_delegate, mount_path, 0, 0,
+          MOUNT_METHOD_ERROR_LOCAL, kLibraryNotLoaded);
+      return;
+    }
+
+    libcros_proxy_->CallGetSizeStats(mount_path, &GetSizeStatsCallback,

[zel, 2011/09/02 21:37:34]

You might want to inline that routine here as well.
So, why is this in libcros? is there anything ChromeOS specific about this call?
can it simply run on any Linux distro?

[tonibarzic, 2011/09/02 21:59:01]

It seemed like a good idea to keep system calls in chromeOS code base,
but yeah, it should work on any Linux distro..

[zel, 2011/09/02 22:00:58]

We should move such functionality here into mount_library.cc instead. There is
no reason to bloat the surface of libcros.

+        callback_delegate);
+  }
+
   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();
@@ skipping 143 matching lines @@
   // Callback for UnmountRemovableDevice method.
   static void UnmountMountPointCallback(void* object,
                                         const char* mount_path,
                                         MountMethodErrorType error,
                                         const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     self->OnUnmountPath(mount_path, error, error_message);
   }
 
+  static void GetSizeStatsCallback(void* object,
+                                   const char* mount_path,
+                                   size_t total_size_kb,
+                                   size_t remaining_size_kb,
+                                   MountMethodErrorType error,
+                                   const char* error_message) {
+    DCHECK(object);
+    CallbackDelegate* callback = static_cast<CallbackDelegate*>(object);
+
+    callback->GetSizeStatsCallback(mount_path,
+        error == MOUNT_METHOD_ERROR_NONE, total_size_kb, remaining_size_kb);
+  }
+
   // Callback for FormatRemovableDevice method.
   static void FormatDeviceCallback(void* object,
                                    const char* file_path,
                                    bool success,
                                    MountMethodErrorType error,
                                    const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     const char* device_path = self->FilePathToDevicePath(file_path);
     if (!device_path) {
@@ skipping 410 matching lines @@
   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 GetSizeStats(const char* mount_path,
+                            CallbackDelegate* callback_delegate) 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) {
   if (stub)
     return new MountLibraryStubImpl();
   else
     return new MountLibraryImpl();
 }
 
 }  // 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);