Add gdata content search to file_manager

chrome/browser/resources/file_manager/js/file_manager.js

 // Copyright (c) 2012 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.
 
 /**
  * FileManager constructor.
  *
  * FileManager objects encapsulate the functionality of the file selector
  * dialogs, as well as the full screen file manager application (though the
  * latter is not yet implemented).
@@ skipping 981 matching lines @@
       this.commands_[key].disabled = !this.canExecute_(key);
   };
 
   /**
    * @param {string} commandId Command identifier.
    * @return {boolean} True if the command can be executed for current
    *                   selection.
    */
   FileManager.prototype.canExecute_ = function(commandId) {
     var readonly = this.isOnReadonlyDirectory();
+    var shouldCreate = !this.directoryModel_.isSearching();
     switch (commandId) {
       case 'copy':
       case 'cut':
         return this.document_.queryCommandEnabled(commandId);
 
       case 'paste':
         return !!this.fileTransferController_ &&
-               this.fileTransferController_.queryPasteCommandEnabled();
+               this.fileTransferController_.queryPasteCommandEnabled() &&
+               shouldCreate;

[SeRya, 2012/05/11 07:17:23]

I recalled that canExecute_ only handles context menu commands. This code
doesn't affect Ctrl-V. Please ensure that Ctrl-C in Downloads and Ctrl-V in
search results doesn't cause copying or break something. Looks like this check
must be in FileTransferManager.canPaste_.

[tbarzic, 2012/05/14 20:44:17]

i have it in FilTransferManager.canPasteOrDrop_

 
       case 'rename':
         return (// Initialized to the point where we have a current directory
                 !readonly &&
                 // Rename not in progress.
                 !this.isRenamingInProgress() &&
                 // Only one file selected.
                 this.selection &&
                 this.selection.totalCount == 1);
 
       case 'delete':
         return (// Initialized to the point where we have a current directory
                 !readonly &&
                 // Rename not in progress.
                 !this.isRenamingInProgress() &&
                 this.selection &&
                 this.selection.totalCount > 0);
 
       case 'newfolder':
         return !readonly &&
+               shouldCreate &&
                (this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE ||
                 this.dialogType_ == FileManager.DialogType.FULL_PAGE);
 
       case 'unmount':
         return true;
 
       case 'format':
         var entry = this.directoryModel_.getCurrentRootDirEntry();
 
         return entry && DirectoryModel.getRootType(entry.fullPath) ==
@@ skipping 232 matching lines @@
       }
     }
   };
 
   /**
    * Handler of file manager operations. Update directory model
    * to reflect operation result iimediatelly (not waiting directory
    * update event).
    */
   FileManager.prototype.onCopyManagerOperationComplete_ = function(event) {
-    var currentPath = this.directoryModel_.getCurrentDirEntry().fullPath;
+    var currentPath =
+        this.directoryModel_.getSearchOrCurrentDirEntry().fullPath;

[SeRya, 2012/05/11 07:17:23]

We gonna prevent paste and drop operation into search into search results. So in
the search state this event may be safely ignored.
this.directoryModel_.getCurrentDirPath() should be used.

[tbarzic, 2012/05/14 20:44:17]

yeah, I agree

[SeRya, 2012/05/15 06:17:01]

So please replece with this.directoryModel_.getCurrentDirPath().

On 2012/05/14 20:44:17, tbarzic wrote:

     function inCurrentDirectory(entry) {
       var fullPath = entry.fullPath;
       var dirPath = fullPath.substr(0, fullPath.length -
                                        entry.name.length - 1);
       return dirPath == currentPath;
     }
     for (var i = 0; i < event.affectedEntries.length; i++) {
       entry = event.affectedEntries[i];
       if (inCurrentDirectory(entry))
         this.directoryModel_.onEntryChanged(entry.name);
@@ skipping 563 matching lines @@
    * Render filename label for grid and list view.
    * @param {Entry} entry The Entry object to render.
    * @return {HTMLDivElement} The label.
    */
   FileManager.prototype.renderFileNameLabel_ = function(entry) {
     // Filename need to be in a '.filename-label' container for correct
     // work of inplace renaming.
     var fileName = this.document_.createElement('div');
     fileName.className = 'filename-label';
 
+    var displayName =
+        this.directoryModel_.getDisplayName(entry.fullPath, entry.name);
+
     fileName.textContent =
-        this.directoryModel_.getCurrentDirEntry().name == '' ?
-            this.getRootLabel_(entry.name) : entry.name;
+        this.directoryModel_.getSearchOrCurrentDirEntry().name == '' ?
+            this.getRootLabel_(displayName) : displayName;
     return fileName;
   };
 
   /**
    * Render the Size column of the detail table.
    *
    * @param {Entry} entry The Entry object to render.
    * @param {string} columnId The id of the column to be rendered.
    * @param {cr.ui.Table} table The table doing the rendering.
    */
@@ skipping 930 matching lines @@
       // in the ribbon.
       // We do not do that if a single video is selected because the UI is
       // cleaner without the ribbon.
       urls = this.getAllUrlsInCurrentDirectory_().filter(
           FileType.isImageOrVideo);
     } else {
       // Pass just the selected items, select the first entry.
       selectedUrl = urls[0];
     }
 
-    var dirPath = this.directoryModel_.getCurrentDirEntry().fullPath;
+    var dirPath = this.directoryModel_.getSearchOrCurrentDirEntry().fullPath;

[SeRya, 2012/05/11 07:17:23]

It should be getCurrentDirPath(). I think the gallery should not show
/gdata/.search/... in the URL bar. It should show current directory path
intitially and then canonical (resolved with getPathForDriveSearchResult) paths.

[tbarzic, 2012/05/14 20:44:17]

Done.

 
     // Push a temporary state which will be replaced every time an individual
     // item is selected in the Gallery.
     this.updateLocation_(false /*push*/, dirPath);
 
     galleryFrame.onload = function() {
       galleryFrame.contentWindow.ImageUtil.metrics = metrics;
       galleryFrame.contentWindow.FileType = FileType;
       galleryFrame.contentWindow.util = util;
 
       // Gallery shoud treat GData folder as readonly even when online
       // until we learn to save files directly to GData.
       var readonly = self.isOnReadonlyDirectory() || self.isOnGData();
-      var currentDir = self.directoryModel_.getCurrentDirEntry();
+      var currentDir = self.directoryModel_.getSearchOrCurrentDirEntry();
       var downloadsDir = self.directoryModel_.getRootsList().item(0);
 
       var gallerySelection;
       var context = {
         // We show the root label in readonly warning (e.g. archive name).
         readonlyDirName:

[SeRya, 2012/05/11 07:17:23]

By the way, it's unlikely renaming in the gallery works properly in the search
results. Event worse it's unlikely it properly show file names.

[tbarzic, 2012/05/14 20:44:17]

gallery is already readonly on gdata, but yes file names weren't displayed
nicely.
I fixed this, but to be hones I'm not too thrilled with the solution (seems
kinda hacky; and I'm not sure it scales well).

             readonly ?
                 (self.isOnGData() ?
                     self.getRootLabel_(
                         DirectoryModel.getRootPath(currentDir.fullPath)) :
                     self.directoryModel_.getRootName()) :
                 null,
         saveDirEntry: readonly ? downloadsDir : currentDir,
         metadataProvider: self.getMetadataProvider(),
         getShareActions: self.getShareActions_.bind(self),
         onNameChange: function(name) {
@@ skipping 48 matching lines @@
 
       path = path + '/';
       div.path = path;
 
       bc.appendChild(div);
 
       if (i == pathNames.length - 1) {
         div.classList.add('breadcrumb-last');
       } else {
         div.addEventListener('click', this.onBreadcrumbClick_.bind(this));
-
         var spacer = doc.createElement('div');
         spacer.className = 'separator';
         bc.appendChild(spacer);
       }
     }
     this.truncateBreadcrumbs_();
   };
 
   FileManager.prototype.isRenamingInProgress = function() {
     return !!this.renameInput_.currentEntry;
@@ skipping 131 matching lines @@
   };
 
   /**
    * Return URL of the current directory or null.
    */
   FileManager.prototype.getCurrentDirectoryURL = function() {
     return this.directoryModel_ &&
         this.directoryModel_.getCurrentDirEntry().toURL();
   };
 
+  /**
+   * Return URL of the search directory, current directory or null.
+   */
+  FileManager.prototype.getSearchOrCurrentDirectoryURL = function() {
+    return this.directoryModel_ &&
+        this.directoryModel_.getSearchOrCurrentDirEntry().toURL();
+  };
+
   FileManager.prototype.deleteEntries = function(entries, force, opt_callback) {
     if (!force) {
       var self = this;
       var msg;
       if (entries.length == 1) {
-        msg = strf('CONFIRM_DELETE_ONE', entries[0].name);
+        var entryName = this.directoryModel_.getDisplayName(entries[0].fullPath,
+                                                            entries[0].name);
+        msg = strf('CONFIRM_DELETE_ONE', entryName);
       } else {
         msg = strf('CONFIRM_DELETE_SOME', entries.length);
       }
 
       this.confirm.show(msg, this.deleteEntries.bind(
           this, entries, true, opt_callback));
       return;
     }
 
     this.directoryModel_.deleteEntries(entries, opt_callback);
@@ skipping 204 matching lines @@
     } else if (this.dialogType_ == FileManager.DialogType.SELECT_OPEN_FILE) {
       selectable = (this.isSelectionAvailable() &&
                     this.selection.directoryCount == 0 &&
                     this.selection.fileCount == 1);
     } else if (this.dialogType_ ==
                FileManager.DialogType.SELECT_OPEN_MULTI_FILE) {
       selectable = (this.isSelectionAvailable() &&
                     this.selection.directoryCount == 0 &&
                     this.selection.fileCount >= 1);
     } else if (this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE) {
-      if (this.isOnReadonlyDirectory()) {
+      if (this.isOnReadonlyDirectory() ||
+          (this.isOnGData() && this.directoryModel_.isSearching())) {
         selectable = false;
       } else {
         selectable = !!this.filenameInput_.value;
       }
     } else if (this.dialogType_ == FileManager.DialogType.FULL_PAGE) {
       // No "select" buttons on the full page UI.
       selectable = true;
     } else {
       throw new Error('Unknown dialog type');
     }
@@ skipping 31 matching lines @@
       this.dispatchDefaultTask_();
       return true;
     }
     if (!this.okButton_.disabled) {
       this.onOk_();
       return true;
     }
     return false;
   };
 
+  /**
+   * Executes directory action (i.e. changes directory). If new directory is a
+   * search result directory, we'll have to calculate its real path before we
+   * actually do the operation.
+   *
+   * @param {DirectoryEntry} entry Directory entry to which directory should be
+   *                               changed.
+   */
   FileManager.prototype.onDirectoryAction = function(entry) {
-    var deviceNumber = this.getDeviceNumber(entry);
-    if (deviceNumber != undefined &&
-        this.mountPoints_[deviceNumber].mountCondition ==
-        'unknown_filesystem') {
-      return this.showButter(str('UNKNOWN_FILESYSTEM_WARNING'));
-    } else if (deviceNumber != undefined &&
-               this.mountPoints_[deviceNumber].mountCondition ==
-               'unsupported_filesystem') {
-      return this.showButter(str('UNSUPPORTED_FILESYSTEM_WARNING'));
-    } else {
+    if (!DirectoryModel.isGDataSearchPath(entry.fullPath))
       return this.directoryModel_.changeDirectory(entry.fullPath);
-    }
+
+    // If we are under gdata search path, the real entries file path may be
+    // different from |entry.fullPath|.
+    var self = this;
+    chrome.fileBrowserPrivate.getPathForDriveSearchResult(entry.toURL(),
+      function(path) {
+        // |path| may be undefined if there was an error. If that is the case,
+        // change to the original file path.
+        var changeToPath = path || entry.fullPath;
+        self.directoryModel_.changeDirectory(changeToPath);
+      });
   };
 
   /**
    * Show or hide the "Low disk space" warning.
    * @param {boolean} show True if the box need to be shown.
    */
   FileManager.prototype.showLowDiskSpaceWarning_ = function(show) {
     var box = this.dialogDom_.querySelector('.downloads-warning');
     if (show) {
       var html = util.htmlUnescape(str('DOWNLOADS_DIRECTORY_WARNING'));
@@ skipping 30 matching lines @@
   /**
    * Update the tab title.
    */
   FileManager.prototype.updateTitle_ = function() {
     this.document_.title = this.getCurrentDirectory().substr(1).replace(
         new RegExp('^' + DirectoryModel.GDATA_DIRECTORY),
         str('GDATA_PRODUCT_NAME'));
   },
 
   /**
+   * Updates search box value when directory gets changed.
+   */
+  FileManager.prototype.updateSearchBoxOnDirChange_ = function() {
+    this.dialogDom_.querySelector('#search-box').value = '';
+  },
+
+  /**
    * Update the UI when the current directory changes.
    *
    * @param {cr.Event} event The directory-changed event.
    */
   FileManager.prototype.onDirectoryChanged_ = function(event) {
     this.updateCommonActionButtons_();
     this.updateOkButton_();
     this.updateBreadcrumbs_();
     this.updateColumnModel_();
+    this.updateSearchBoxOnDirChange_();
 
     // Sometimes we rescan the same directory (when mounting GData lazily first,
     // then for real). Do not update the location then.
     if (event.newDirEntry.fullPath != event.previousDirEntry.fullPath) {
       this.updateLocation_(event.initial, event.newDirEntry.fullPath);
     }
 
     this.checkFreeSpace_(this.getCurrentDirectory());
 
     this.updateTitle_();
@@ skipping 85 matching lines @@
             if (!result) {
               console.log('Failed to remove file watch');
             }
           });
       this.watchedDirectoryUrl_ = null;
     }
   };
 
   FileManager.prototype.onFileChanged_ = function(event) {
     // We receive a lot of events even in folders we are not interested in.
-    if (encodeURI(event.fileUrl) == this.getCurrentDirectoryURL())
+    if (encodeURI(event.fileUrl) == this.getSearchOrCurrentDirectoryURL())

[SeRya, 2012/05/11 07:17:23]

Are you sure event.fileUrl may ever point to "/gdata/.search"? Most likely it
only points to canonical file paths. If so comparing URL with search entry
doesn't makes sense. On the other hand any change in /gdata/... may affect
search results.

[tbarzic, 2012/05/14 20:44:17]

Done.

       this.directoryModel_.rescanLater();
   };
 
   FileManager.prototype.initiateRename_ = function() {
     var item = this.currentList_.ensureLeadItemExists();
     if (!item)
       return;
     var label = item.querySelector('.filename-label');
     var input = this.renameInput_;
 
@@ skipping 59 matching lines @@
       input.validation_ = false;
       // Alert dialog restores focus unless the item removed from DOM.
       if (this.document_.activeElement != input)
         this.cancelRename_();
     }
 
     if (!this.validateFileName_(newName, validationDone.bind(this)))
       return;
 
     function onError(err) {
-      nameNode.textContent = entry.name;
-      this.alert.show(strf('ERROR_RENAMING', entry.name,
+      var entryName =
+          this.directoryModel_.getDisplayName(entry.fullPath, entry.name);
+      nameNode.textContent = entryName;
+      this.alert.show(strf('ERROR_RENAMING', entryName,
                            getFileErrorString(err.code)));
     }
 
     this.cancelRename_();
     // Optimistically apply new name immediately to avoid flickering in
     // case of success.
     nameNode.textContent = newName;
 
-    this.directoryModel_.doesExist(newName, function(exists, isFile) {
+    this.directoryModel_.doesExist(entry, newName, function(exists, isFile) {
       if (!exists) {
         this.directoryModel_.renameEntry(entry, newName, onError.bind(this));
       } else {
-        nameNode.textContent = entry.name;
+        nameNode.textContent =
+            this.directoryModel_.getDisplayName(entry.fullPath, entry.name);
         var message = isFile ? 'FILE_ALREADY_EXISTS' :
                                'DIRECTORY_ALREADY_EXISTS';
         this.alert.show(strf(message, newName));
       }
     }.bind(this));
   };
 
   FileManager.prototype.cancelRename_ = function() {
     this.renameInput_.currentEntry = null;
 
@@ skipping 457 matching lines @@
 
   /**
    * Handle a click of the ok button.
    *
    * The ok button has different UI labels depending on the type of dialog, but
    * in code it's always referred to as 'ok'.
    *
    * @param {Event} event The click event.
    */
   FileManager.prototype.onOk_ = function(event) {
-    var currentDirUrl = this.getCurrentDirectoryURL();
+    var currentDirUrl = this.getSearchOrCurrentDirectoryURL();
 
     if (currentDirUrl.charAt(currentDirUrl.length - 1) != '/')
       currentDirUrl += '/';
 
     var self = this;
     if (this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE) {
       // Save-as doesn't require a valid selection from the list, since
       // we're going to take the filename from the text input.
       var filename = this.filenameInput_.value;
       if (!filename)
         throw new Error('Missing filename!');
       if (!this.validateFileName_(filename))
         return;
 
       var singleSelection = {
         urls: [currentDirUrl + encodeURIComponent(filename)],

[SeRya, 2012/05/11 07:17:23]

It's gonna construct URL like filesystem://.../gdata/.search/new-file-name.ext.
I don't think it makes sense.

[tbarzic, 2012/05/14 20:44:17]

we shouldn't get here in save-as dialog

         multiple: false,
         filterIndex: self.getSelectedFilterIndex_(filename)
       };
 
       function resolveCallback(victim) {
         if (victim instanceof FileError) {
           // File does not exist.
           self.selectFilesAndClose_(singleSelection);
           return;
         }
 
         if (victim.isDirectory) {
           // Do not allow to overwrite directory.
           self.alert.show(strf('DIRECTORY_ALREADY_EXISTS', filename));
         } else {
           self.confirm.show(strf('CONFIRM_OVERWRITE_FILE', filename),
                             function() {
                               // User selected Ok from the confirm dialog.
                               self.selectFilesAndClose_(singleSelection);
                             });
         }
       }
 
       this.resolvePath(this.getCurrentDirectory() + '/' + filename,

[SeRya, 2012/05/11 07:17:23]

I don't think it makes sense to check file existence in current directory if
search results is active. May be we should disable OK button on the "Save as"
dialog when no file selected of file name in the input box is not equal to the
selected file name. Or even better we may disable search in this dialog at all.
Please, clarify it with the UX team.

[tbarzic, 2012/05/14 20:44:17]

grr..I had left you a comment here, but forgot to publish it last night :/
(basically, that save as dialog is TBD; same for the media player)

I chatted with josh about this, and we decided that removing search box from
save as dialog is probably the way to go.

           resolveCallback, resolveCallback);
       return;
     }
 
     var files = [];
     var selectedIndexes = this.currentList_.selectionModel.selectedIndexes;
 
     // All other dialog types require at least one selected list item.
     // The logic to control whether or not the ok button is enabled should
     // prevent us from ever getting here, but we sanity check to be sure.
     if (!selectedIndexes.length)
       throw new Error('Nothing selected!');
 
     var dm = this.directoryModel_.getFileList();
     for (var i = 0; i < selectedIndexes.length; i++) {
       var entry = dm.item(selectedIndexes[i]);
       if (!entry) {
         console.log('Error locating selected file at index: ' + i);
         continue;
       }
 
       files.push(currentDirUrl + encodeURIComponent(entry.name));

[SeRya, 2012/05/11 07:17:23]

May be just entry.toURL()? Is it OK to not resolve it with
getPathForDriveSearchResult?

[tbarzic, 2012/05/14 20:44:17]

I don't think it's "necessary", but it would probably be a good idea..

[tbarzic, 2012/05/14 20:44:17]

Done.

     }
 
     // Multi-file selection has no other restrictions.
     if (this.dialogType_ == FileManager.DialogType.SELECT_OPEN_MULTI_FILE) {
       var multipleSelection = {
         urls: files,
         multiple: true
       };
       this.selectFilesAndClose_(multipleSelection);
       return;
@@ skipping 125 matching lines @@
 
     if (oldValue) {
       event.target.removeAttribute('checked');
     } else {
       event.target.setAttribute('checked', 'checked');
     }
   };
 
   FileManager.prototype.onSearchBoxUpdate_ = function(event) {
     var searchString = this.dialogDom_.querySelector('#search-box').value;
-    if (searchString) {
-      this.directoryModel_.addFilter(
-          'searchbox',
-          function(e) {
-            return e.name.substr(0, searchString.length) == searchString;
-          });
-    } else {
-      this.directoryModel_.removeFilter('searchbox');
-    }
+    this.directoryModel_.search(searchString);
+    this.updateOkButton_();
   };
 
   FileManager.prototype.decorateSplitter = function(splitterElement) {
     var self = this;
 
     var Splitter = cr.ui.Splitter;
 
     var customSplitter = cr.ui.define('div');
 
     customSplitter.prototype = {
@@ skipping 113 matching lines @@
 
     this.directoryModel_.addEventListener('scan-completed', maybeShowBanner);
     this.directoryModel_.addEventListener('rescan-completed', maybeShowBanner);
 
     var style = this.document_.createElement('link');
     style.rel = 'stylesheet';
     style.href = 'css/gdrive_welcome.css';
     this.document_.head.appendChild(style);
   };
 })();