Adding support for mount point different from removable devices to MountLibrary

chrome/browser/chromeos/extensions/file_browser_event_router.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/extensions/file_browser_event_router.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/values.h"
@@ skipping 37 matching lines @@
   DictionaryValue* result = new DictionaryValue();
   result->SetString("mountPath", disk->mount_path());
   result->SetString("devicePath", disk->device_path());
   result->SetString("label", disk->device_label());
   result->SetString("deviceType", DeviceTypeToString(disk->device_type()));
   result->SetInteger("totalSizeKB", disk->total_size() / 1024);
   result->SetBoolean("readOnly", disk->is_read_only());
   return result;
 }
 
+const char* MountTypeToString(chromeos::MountType type) {
+  switch (type) {
+    case chromeos::MOUNT_TYPE_DEVICE:
+      return "device";
+    case chromeos::MOUNT_TYPE_ARCHIVE:
+      return "file";
+    case chromeos::MOUNT_TYPE_NETWORK_STORAGE:
+      return "network";
+    case chromeos::MOUNT_TYPE_INVALID:
+      return "invalid";
+    default:
+      NOTREACHED();
+  }
+  return "";
+}
+
+const char* MountErrorToString(chromeos::MountError error) {
+  switch (error) {
+    case chromeos::MOUNT_ERROR_NONE:
+      return "success";
+    case chromeos::MOUNT_ERROR_UNKNOWN:
+      return "unknown";
+    case chromeos::MOUNT_ERROR_INTERNAL:
+      return "internal";
+    case chromeos::MOUNT_ERROR_UNKNOWN_FILESYSTEM:
+      return "unknown_filesystem";
+    case chromeos::MOUNT_ERROR_UNSUPORTED_FILESYSTEM:
+      return "unsuported_filesystem";
+    case chromeos::MOUNT_ERROR_INVALID_ARCHIVE:
+      return "invalid_archive";
+    case chromeos::MOUNT_ERROR_LIBRARY_NOT_LOADED:
+      return "libcros_missing";
+    default:
+      NOTREACHED();
+  }
+  return "";
+}
+
 ExtensionFileBrowserEventRouter::ExtensionFileBrowserEventRouter()
     : delegate_(new ExtensionFileBrowserEventRouter::FileWatcherDelegate()),
       profile_(NULL) {
 }
 
 ExtensionFileBrowserEventRouter::~ExtensionFileBrowserEventRouter() {
   DCHECK(file_watchers_.empty());
   STLDeleteValues(&file_watchers_);
 
   if (!profile_)
@@ skipping 93 matching lines @@
     const std::string& device_path) {
   if (event == chromeos::MOUNT_DEVICE_ADDED) {
     OnDeviceAdded(device_path);
   } else if (event == chromeos::MOUNT_DEVICE_REMOVED) {
     OnDeviceRemoved(device_path);
   } else if (event == chromeos::MOUNT_DEVICE_SCANNED) {
     OnDeviceScanned(device_path);
   }
 }
 
+void ExtensionFileBrowserEventRouter::MountCompleted(
+    chromeos::MountError error_code,
+    const std::string& source_path,
+    chromeos::MountType type,
+    const std::string& mount_path) {
+  DispatchMountCompletedEvent(error_code, source_path, type, mount_path);
+}
+
 void ExtensionFileBrowserEventRouter::HandleFileWatchNotification(
     const FilePath& local_path, bool got_error) {
   base::AutoLock lock(lock_);
   WatcherMap::const_iterator iter = file_watchers_.find(local_path);
   if (iter == file_watchers_.end()) {
     NOTREACHED();
     return;
   }
   DispatchFolderChangeEvent(iter->second->virtual_path, got_error,
                             iter->second->extensions);
@@ skipping 45 matching lines @@
   DictionaryValue* disk_info = DiskToDictionaryValue(disk);
   mount_info->Set("volumeInfo", disk_info);
 
   std::string args_json;
   base::JSONWriter::Write(&args, false /* pretty_print */, &args_json);
   profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
       extension_event_names::kOnFileBrowserDiskChanged, args_json, NULL,
       GURL());
 }
 
+void ExtensionFileBrowserEventRouter::DispatchMountCompletedEvent(
+    chromeos::MountError error_code, const std::string& source_path,
+    chromeos::MountType type, const std::string& mount_path ) {
+  if (!profile_ || type == chromeos::MOUNT_TYPE_INVALID) {
+    NOTREACHED();
+    return;
+  }
+
+  ListValue args;
+  DictionaryValue* mount_info = new DictionaryValue();
+  args.Append(mount_info);
+  mount_info->SetString("sourcePath", source_path);
+  mount_info->SetString("eventType", MountErrorToString(error_code));
+  mount_info->SetString("mountType", MountTypeToString(type));
+  mount_info->SetString("mountPath", mount_path);
+LOG(WARNING) << "MountCompleted" << error_code << source_path;
+  std::string args_json;
+  base::JSONWriter::Write(&args, false /* pretty_print */, &args_json);
+  profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
+      extension_event_names::kOnFileBrowserMountCompleted, args_json, NULL,
+      GURL());
+}
+
 void ExtensionFileBrowserEventRouter::OnDiskAdded(
     const chromeos::MountLibrary::Disk* disk) {
   VLOG(1) << "Disk added: " << disk->device_path();
   if (disk->device_path().empty()) {
     VLOG(1) << "Empty system path for " << disk->device_path();
     return;
   }
   if (disk->is_parent()) {
     if (!disk->has_media()) {
       HideDeviceNotification(disk->system_path());
       return;
     }
   }
 
   // If disk is not mounted yet, give it a try.
   if (disk->mount_path().empty()) {
     // Initiate disk mount operation.
     chromeos::MountLibrary* lib =
         chromeos::CrosLibrary::Get()->GetMountLibrary();
-    lib->MountPath(disk->device_path().c_str());
+    lib->MountPath(disk->device_path().c_str(),
+                   chromeos::MOUNT_TYPE_DEVICE,
+                   chromeos::MountPathOptions());  // Unused.
   }
 }
 
 void ExtensionFileBrowserEventRouter::OnDiskRemoved(
     const chromeos::MountLibrary::Disk* disk) {
   VLOG(1) << "Disk removed: " << disk->device_path();
   HideDeviceNotification(disk->system_path());
   MountPointMap::iterator iter = mounted_devices_.find(disk->device_path());
   if (iter == mounted_devices_.end())
     return;
@@ skipping 117 matching lines @@
           local_path,
           true));     // got_error
 }
 
 void
 ExtensionFileBrowserEventRouter::FileWatcherDelegate::HandleFileWatchOnUIThread(
      const FilePath& local_path, bool got_error) {
   ExtensionFileBrowserEventRouter::GetInstance()->HandleFileWatchNotification(
       local_path, got_error);
 }