Rewritten MountLibrary to work with non-blocking mount API calls in libcros....

chrome/browser/ui/webui/filebrowse_ui.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/ui/webui/filebrowse_ui.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 46 matching lines @@
 #include "chrome/browser/chromeos/cros/mount_library.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif
 
 // Maximum number of search results to return in a given search. We should
 // eventually remove this.
 static const int kMaxSearchResults = 100;
 static const char kPropertyPath[] = "path";
 static const char kPropertyTitle[] = "title";
 static const char kPropertyDirectory[] = "isDirectory";
-static const char kPicasawebUserPrefix[] =
-    "http://picasaweb.google.com/data/feed/api/user/";
-static const char kPicasawebDefault[] = "/albumid/default";
-static const char kPicasawebDropBox[] = "/home";
-static const char kPicasawebBaseUrl[] = "http://picasaweb.google.com/";
 static const char kMediaPath[] = "/media";
 static const char kFilebrowseURLHash[] = "chrome://filebrowse#";
 static const int kPopupLeft = 0;
 static const int kPopupTop = 0;
 
 class FileBrowseUIHTMLSource : public ChromeURLDataManager::DataSource {
  public:
   FileBrowseUIHTMLSource();
 
   // Called when the network layer has requested a resource underneath
@@ skipping 13 matching lines @@
 
 class TaskProxy;
 
 // The handler for Javascript messages related to the "filebrowse" view.
 class FilebrowseHandler : public net::DirectoryLister::DirectoryListerDelegate,
                           public WebUIMessageHandler,
 #if defined(OS_CHROMEOS)
                           public chromeos::MountLibrary::Observer,
 #endif
                           public base::SupportsWeakPtr<FilebrowseHandler>,
-                          public URLFetcher::Delegate,
                           public DownloadManager::Observer,
                           public DownloadItem::Observer {
  public:
   FilebrowseHandler();
   virtual ~FilebrowseHandler();
 
   // Init work after Attach.
   void Init();
 
   // DirectoryLister::DirectoryListerDelegate methods:
   virtual void OnListFile(
       const net::DirectoryLister::DirectoryListerData& data);
   virtual void OnListDone(int error);
 
   // WebUIMessageHandler implementation.
   virtual WebUIMessageHandler* Attach(WebUI* web_ui);
   virtual void RegisterMessages();
 
 #if defined(OS_CHROMEOS)
-  void MountChanged(chromeos::MountLibrary* obj,
-                    chromeos::MountEventType evt,
-                    const std::string& path);
+  // chromeos::MountLibrary::Observer interface
+  virtual void DiskChanged(chromeos::MountLibraryEventType event,
+                           const chromeos::MountLibrary::Disk* disk);
+  virtual void DeviceChanged(chromeos::MountLibraryEventType event,
+                             const std::string& device_path);
 #endif
 
   // DownloadItem::Observer interface
   virtual void OnDownloadUpdated(DownloadItem* download);
   virtual void OnDownloadFileCompleted(DownloadItem* download);
   virtual void OnDownloadOpened(DownloadItem* download) { }
 
   // DownloadManager::Observer interface
   virtual void ModelChanged();
 
   // Callback for the "getRoots" message.
   void HandleGetRoots(const ListValue* args);
 
   void GetChildrenForPath(const FilePath& path, bool is_refresh);
 
-  void OnURLFetchComplete(const URLFetcher* source,
-                          const GURL& url,
-                          const net::URLRequestStatus& status,
-                          int response_code,
-                          const ResponseCookies& cookies,
-                          const std::string& data);
-
   // Callback for the "getChildren" message.
   void HandleGetChildren(const ListValue* args);
   // Callback for the "refreshDirectory" message.
   void HandleRefreshDirectory(const ListValue* args);
   void HandleIsAdvancedEnabled(const ListValue* args);
 
   // Callback for the "getMetadata" message.
   void HandleGetMetadata(const ListValue* args);
 
   // Callback for the "openNewWindow" message.
   void OpenNewFullWindow(const ListValue* args);
   void OpenNewPopupWindow(const ListValue* args);
 
-  // Callback for the "uploadToPicasaweb" message.
-  void UploadToPicasaweb(const ListValue* args);
-
   // Callback for the "getDownloads" message.
   void HandleGetDownloads(const ListValue* args);
 
   void HandleCreateNewFolder(const ListValue* args);
 
   void PlayMediaFile(const ListValue* args);
   void EnqueueMediaFile(const ListValue* args);
 
   void HandleDeleteFile(const ListValue* args);
   void HandleCopyFile(const ListValue* value);
   void CopyFile(const FilePath& src, const FilePath& dest, TaskProxy* task);
   void DeleteFile(const FilePath& path, TaskProxy* task);
   void FireDeleteComplete(const FilePath& path);
   void FireCopyComplete(const FilePath& src, const FilePath& dest);
 
   void HandlePauseToggleDownload(const ListValue* args);
 
   void HandleCancelDownload(const ListValue* args);
   void HandleAllowDownload(const ListValue* args);
 
   void CreateNewFolder(const FilePath& path) const;
 
-  void ReadInFile();
-  void FireUploadComplete();
-
-  void SendPicasawebRequest(URLRequestContextGetter* request_context);
-
   // Callback for the "validateSavePath" message.
   void HandleValidateSavePath(const ListValue* args);
 
   // Validate a save path on file thread.
   void ValidateSavePathOnFileThread(const FilePath& save_path, TaskProxy* task);
 
   // Fire save path validation result to JS onValidatedSavePath.
   void FireOnValidatedSavePathOnUIThread(bool valid, const FilePath& save_path);
 
  private:
@@ skipping 12 matching lines @@
   void SendNewDownload(DownloadItem* download);
 
   bool ValidateSaveDir(const FilePath& save_dir, bool exists) const;
   bool AccessDisabled(const FilePath& path) const;
 
   scoped_ptr<ListValue> filelist_value_;
   FilePath currentpath_;
   Profile* profile_;
   TabContents* tab_contents_;
   std::string current_file_contents_;
-  std::string current_file_uploaded_;
-  int upload_response_code_;
   TaskProxy* current_task_;
   scoped_refptr<net::DirectoryLister> lister_;
   bool is_refresh_;
-  scoped_ptr<URLFetcher> fetch_;
 
   DownloadManager* download_manager_;
   typedef std::vector<DownloadItem*> DownloadList;
   DownloadList active_download_items_;
   DownloadList download_items_;
   bool got_first_download_list_;
   DISALLOW_COPY_AND_ASSIGN(FilebrowseHandler);
 };
 
 class TaskProxy : public base::RefCountedThreadSafe<TaskProxy> {
@@ skipping 11 matching lines @@
   // TaskProxy is created on the UI thread, so in some cases,
   // we need to post back to the UI thread for destruction.
   void DeleteOnUIThread() {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &TaskProxy::DoNothing));
   }
 
   void DoNothing() {}
 
-  void ReadInFileProxy() {
-    if (handler_)
-      handler_->ReadInFile();
-    DeleteOnUIThread();
-  }
-
-  void DeleteFetcher(URLFetcher* fetch) {
-    delete fetch;
-  }
-
-  void SendPicasawebRequestProxy(URLRequestContextGetter* request_context) {
-    if (handler_)
-      handler_->SendPicasawebRequest(request_context);
-    DeleteOnUIThread();
-  }
-
-  void FireUploadCompleteProxy() {
-    if (handler_)
-      handler_->FireUploadComplete();
-  }
-
   void DeleteFileProxy() {
     if (handler_)
       handler_->DeleteFile(src_, this);
   }
 
   void CopyFileProxy() {
     if (handler_)
       handler_->CopyFile(src_, dest_, this);
   }
 
@@ skipping 64 matching lines @@
   localized_strings.SetString("allowdownload",
       l10n_util::GetStringUTF16(IDS_FILEBROWSER_CONFIRM_DOWNLOAD));
   localized_strings.SetString("filenameprompt",
       l10n_util::GetStringUTF16(IDS_FILEBROWSER_PROMPT_FILENAME));
   localized_strings.SetString("save",
       l10n_util::GetStringUTF16(IDS_FILEBROWSER_SAVE));
   localized_strings.SetString("newfolder",
       l10n_util::GetStringUTF16(IDS_FILEBROWSER_NEW_FOLDER));
   localized_strings.SetString("open",
       l10n_util::GetStringUTF16(IDS_FILEBROWSER_OPEN));
-  localized_strings.SetString("picasaweb",
-      l10n_util::GetStringUTF16(IDS_FILEBROWSER_UPLOAD_PICASAWEB));
-  localized_strings.SetString("flickr",
-      l10n_util::GetStringUTF16(IDS_FILEBROWSER_UPLOAD_FLICKR));
-  localized_strings.SetString("email",
-      l10n_util::GetStringUTF16(IDS_FILEBROWSER_UPLOAD_EMAIL));
   localized_strings.SetString("delete",
       l10n_util::GetStringUTF16(IDS_FILEBROWSER_DELETE));
   localized_strings.SetString("enqueue",
       l10n_util::GetStringUTF16(IDS_FILEBROWSER_ENQUEUE));
   localized_strings.SetString("mediapath", kMediaPath);
   FilePath default_download_path;
   if (!PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS,
                         &default_download_path)) {
     NOTREACHED();
   }
@@ skipping 18 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // FilebrowseHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 FilebrowseHandler::FilebrowseHandler()
     : profile_(NULL),
       tab_contents_(NULL),
       is_refresh_(false),
-      fetch_(NULL),
       download_manager_(NULL),
       got_first_download_list_(false) {
   lister_ = NULL;
 #if defined(OS_CHROMEOS)
   chromeos::MountLibrary* lib =
       chromeos::CrosLibrary::Get()->GetMountLibrary();
   lib->AddObserver(this);
 #endif
 }
 
 FilebrowseHandler::~FilebrowseHandler() {
 #if defined(OS_CHROMEOS)
   chromeos::MountLibrary* lib =
       chromeos::CrosLibrary::Get()->GetMountLibrary();
   lib->RemoveObserver(this);
 #endif
   if (lister_.get()) {
     lister_->Cancel();
     lister_->set_delegate(NULL);
   }
 
   ClearDownloadItems();
   download_manager_->RemoveObserver(this);
-  URLFetcher* fetch = fetch_.release();
-  if (fetch) {
-    scoped_refptr<TaskProxy> task = new TaskProxy(AsWeakPtr(), currentpath_);
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(
-            task.get(), &TaskProxy::DeleteFetcher, fetch));
-  }
 }
 
 WebUIMessageHandler* FilebrowseHandler::Attach(WebUI* web_ui) {
   // Create our favicon data source.
   profile_ = web_ui->GetProfile();
   profile_->GetChromeURLDataManager()->AddDataSource(
       new FaviconSource(profile_));
   tab_contents_ = web_ui->tab_contents();
   return WebUIMessageHandler::Attach(web_ui);
 }
 
 void FilebrowseHandler::Init() {
   download_manager_ = profile_->GetDownloadManager();
   download_manager_->AddObserver(this);
-  static bool sent_request = false;
-  if (!sent_request &&
-      !chromeos::UserManager::Get()->logged_in_user().email().empty()) {
-    // If we have not sent a request before, we should do one in order to
-    // ensure that we have the correct cookies. This is for uploads.
-    scoped_refptr<TaskProxy> task =
-        new TaskProxy(AsWeakPtr(), currentpath_);
-    current_task_ = task;
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(task.get(),
-                          &TaskProxy::SendPicasawebRequestProxy,
-                          profile_->GetRequestContext()));
-    sent_request = true;
-  }
 }
 
 void FilebrowseHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("getRoots",
       NewCallback(this, &FilebrowseHandler::HandleGetRoots));
   web_ui_->RegisterMessageCallback("getChildren",
       NewCallback(this, &FilebrowseHandler::HandleGetChildren));
   web_ui_->RegisterMessageCallback("getMetadata",
       NewCallback(this, &FilebrowseHandler::HandleGetMetadata));
   web_ui_->RegisterMessageCallback("openNewPopupWindow",
       NewCallback(this, &FilebrowseHandler::OpenNewPopupWindow));
   web_ui_->RegisterMessageCallback("openNewFullWindow",
       NewCallback(this, &FilebrowseHandler::OpenNewFullWindow));
-  web_ui_->RegisterMessageCallback("uploadToPicasaweb",
-      NewCallback(this, &FilebrowseHandler::UploadToPicasaweb));
   web_ui_->RegisterMessageCallback("getDownloads",
       NewCallback(this, &FilebrowseHandler::HandleGetDownloads));
   web_ui_->RegisterMessageCallback("createNewFolder",
       NewCallback(this, &FilebrowseHandler::HandleCreateNewFolder));
   web_ui_->RegisterMessageCallback("playMediaFile",
       NewCallback(this, &FilebrowseHandler::PlayMediaFile));
   web_ui_->RegisterMessageCallback("enqueueMediaFile",
       NewCallback(this, &FilebrowseHandler::EnqueueMediaFile));
   web_ui_->RegisterMessageCallback("pauseToggleDownload",
       NewCallback(this, &FilebrowseHandler::HandlePauseToggleDownload));
@@ skipping 20 matching lines @@
   GetChildrenForPath(dir_path, true);
 };
 
 void FilebrowseHandler::FireCopyComplete(const FilePath& src,
                                          const FilePath& dest) {
   // Notify the UI somehow.
   FilePath dir_path = dest.DirName();
   GetChildrenForPath(dir_path, true);
 };
 
-void FilebrowseHandler::FireUploadComplete() {
 #if defined(OS_CHROMEOS)
-  DictionaryValue info_value;
-  info_value.SetString("path", current_file_uploaded_);
-
-  std::string username;
-  chromeos::UserManager* user_man = chromeos::UserManager::Get();
-  username = user_man->logged_in_user().email();
-
-  if (username.empty()) {
-    LOG(ERROR) << "Unable to get username";
-    return;
-  }
-  int location = username.find_first_of('@', 0);
-  if (location <= 0) {
-    LOG(ERROR) << "Username not formatted correctly";
-    return;
-  }
-  username = username.erase(username.find_first_of('@', 0));
-  std::string picture_url = kPicasawebBaseUrl;
-  picture_url += username;
-  picture_url += kPicasawebDropBox;
-  info_value.SetString("url", picture_url);
-  info_value.SetInteger("status_code", upload_response_code_);
-  web_ui_->CallJavascriptFunction("uploadComplete", info_value);
-#endif
-}
-
-#if defined(OS_CHROMEOS)
-void FilebrowseHandler::MountChanged(chromeos::MountLibrary* obj,
-                                     chromeos::MountEventType evt,
-                                     const std::string& path) {
-  if (evt == chromeos::DISK_REMOVED ||
-      evt == chromeos::DISK_CHANGED) {
+void FilebrowseHandler::DiskChanged(chromeos::MountLibraryEventType event,
+                                    const chromeos::MountLibrary::Disk* disk) {
+  if (event == chromeos::MOUNT_DISK_REMOVED ||
+      event == chromeos::MOUNT_DISK_CHANGED) {
     web_ui_->CallJavascriptFunction("rootsChanged");
   }
 }
+
+void FilebrowseHandler::DeviceChanged(chromeos::MountLibraryEventType event,
+                                      const std::string& device_path) {
+}
 #endif
 
-void FilebrowseHandler::OnURLFetchComplete(const URLFetcher* source,
-                                           const GURL& url,
-                                           const net::URLRequestStatus& status,
-                                           int response_code,
-                                           const ResponseCookies& cookies,
-                                           const std::string& data) {
-  upload_response_code_ = response_code;
-  VLOG(1) << "Response code: " << response_code;
-  VLOG(1) << "Request url: " << url;
-  if (StartsWithASCII(url.spec(), kPicasawebUserPrefix, true)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        NewRunnableMethod(current_task_, &TaskProxy::FireUploadCompleteProxy));
-  }
-  fetch_.reset();
-}
-
 void FilebrowseHandler::HandleGetRoots(const ListValue* args) {
   ListValue results_value;
   DictionaryValue info_value;
   // TODO(dhg): add other entries, make this more general
 #if defined(OS_CHROMEOS)
-  chromeos::MountLibrary* lib =
-      chromeos::CrosLibrary::Get()->GetMountLibrary();
-  const chromeos::MountLibrary::DiskVector& disks = lib->disks();
-
-  for (size_t i = 0; i < disks.size(); ++i) {
-    if (!disks[i].mount_path.empty()) {
+  chromeos::MountLibrary* lib = chromeos::CrosLibrary::Get()->GetMountLibrary();
+  for (chromeos::MountLibrary::DiskMap::const_iterator iter =
+          lib->disks().begin();
+       iter != lib->disks().end();
+       ++iter) {
+    const chromeos::MountLibrary::Disk* disk = iter->second;
+    if (!disk->mount_path().empty()) {
       DictionaryValue* page_value = new DictionaryValue();
-      page_value->SetString(kPropertyPath, disks[i].mount_path);
-      FilePath currentpath(disks[i].mount_path);
+      page_value->SetString(kPropertyPath, disk->mount_path());
+      FilePath currentpath(disk->mount_path());
       std::string filename;
       filename = currentpath.BaseName().value();
       page_value->SetString(kPropertyTitle, filename);
       page_value->SetBoolean(kPropertyDirectory, true);
       results_value.Append(page_value);
     }
   }
 #else
   DictionaryValue* page_value = new DictionaryValue();
   page_value->SetString(kPropertyPath, "/media");
@@ skipping 145 matching lines @@
   browser::Navigate(&params);
   // TODO(beng): The following two calls should be automatic by Navigate().
   if (popup) {
     // TODO(dhg): Remove these from being hardcoded. Allow javascript
     // to specify.
     params.browser->window()->SetBounds(gfx::Rect(0, 0, 400, 300));
   }
   params.browser->window()->Show();
 }
 
-void FilebrowseHandler::SendPicasawebRequest(
-    URLRequestContextGetter* request_context) {
-#if defined(OS_CHROMEOS)
-  fetch_.reset(URLFetcher::Create(0,
-                                  GURL(kPicasawebBaseUrl),
-                                  URLFetcher::GET,
-                                  this));
-  fetch_->set_request_context(request_context);
-  fetch_->Start();
-#endif
-}
-
-void FilebrowseHandler::ReadInFile() {
-#if defined(OS_CHROMEOS)
-  // Get the users username
-  std::string username;
-  chromeos::UserManager* user_man = chromeos::UserManager::Get();
-  username = user_man->logged_in_user().email();
-
-  if (username.empty()) {
-    LOG(ERROR) << "Unable to get username";
-    return;
-  }
-  int location = username.find_first_of('@', 0);
-  if (location <= 0) {
-    LOG(ERROR) << "Username not formatted correctly";
-    return;
-  }
-  username = username.erase(username.find_first_of('@', 0));
-  std::string url = kPicasawebUserPrefix;
-  url += username;
-  url += kPicasawebDefault;
-
-  FilePath currentpath(current_file_uploaded_);
-  // Get the filename
-  std::string filename;
-  filename = currentpath.BaseName().value();
-  std::string filecontents;
-  if (!file_util::ReadFileToString(currentpath, &filecontents)) {
-    LOG(ERROR) << "Unable to read this file:" << currentpath.value();
-    return;
-  }
-  fetch_.reset(URLFetcher::Create(0,
-                                  GURL(url),
-                                  URLFetcher::POST,
-                                  this));
-  fetch_->set_upload_data("image/jpeg", filecontents);
-  // Set the filename on the server
-  std::string slug = "Slug: ";
-  slug += filename;
-  fetch_->set_extra_request_headers(slug);
-  fetch_->set_request_context(profile_->GetRequestContext());
-  fetch_->Start();
-#endif
-}
-
-// This is just a prototype for allowing generic uploads to various sites
-// TODO(dhg): Remove this and implement general upload.
-void FilebrowseHandler::UploadToPicasaweb(const ListValue* args) {
-#if defined(OS_CHROMEOS)
-  std::string search_string = UTF16ToUTF8(ExtractStringValue(args));
-  current_file_uploaded_ = search_string;
-  //  ReadInFile();
-  FilePath current_path(search_string);
-  scoped_refptr<TaskProxy> task = new TaskProxy(AsWeakPtr(), current_path);
-  current_task_ = task;
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(
-          task.get(), &TaskProxy::ReadInFileProxy));
-#endif
-}
 
 void FilebrowseHandler::GetChildrenForPath(const FilePath& path,
                                            bool is_refresh) {
   if (path.empty())
     return;
 
   filelist_value_.reset(new ListValue());
   currentpath_ = path;
 
   if (lister_.get()) {
@@ skipping 415 matching lines @@
     }
   }
 
   return NULL;
 }
 
 const int FileBrowseUI::kPopupWidth = 250;
 const int FileBrowseUI::kPopupHeight = 300;
 const int FileBrowseUI::kSmallPopupWidth = 250;
 const int FileBrowseUI::kSmallPopupHeight = 50;