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 = !util.isSpecialReadonlyDirectory(
+        this.directoryModel_.getCurrentDirEntry().fullPath);

[SeRya, 2012/05/10 08:44:16]

I think here should not be difference between local directory search and gdata
search. In both cases creating a directory makes little sense. In case of local
directory search new directory may immediately disappear as it doesn't
correspond to the query before the user gave it a meaningful name.

It should be this.directoryModel_.isSearch() or something like that.

[tbarzic, 2012/05/10 23:28:02]

Done.

     switch (commandId) {
       case 'copy':
       case 'cut':
         return this.document_.queryCommandEnabled(commandId);
 
       case 'paste':
         return !!this.fileTransferController_ &&
-               this.fileTransferController_.queryPasteCommandEnabled();
+               this.fileTransferController_.queryPasteCommandEnabled() &&
+               shouldCreate;
 
       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 816 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.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 1008 matching lines @@
     var path = rootPathNames.join('/') + '/';
     var doc = this.document_;
 
     for (var i = 0; i < pathNames.length; i++) {
       var pathName = pathNames[i];
       path += pathName;
 
       var div = doc.createElement('div');
 
       div.className = 'breadcrumb-path';
-      div.textContent = i == 0 ? this.getRootLabel_(path) : pathName;
+      // We normally shouldn't be updating breadcrumbs for gdata search paths
+      // (we have to use getDisplayName for these paths), but we have to handle
+      // the case when user explicitly navigates to
+      // chrome://files/#/gdata/.search/foo.
+      div.textContent = i == 0 ? this.getRootLabel_(path) :
+                                 this.directoryModel_.getDisplayName(path,
+                                                                     pathName);
 
       path = path + '/';
       div.path = path;
 
       bc.appendChild(div);
 
-      if (i == pathNames.length - 1) {
-        div.classList.add('breadcrumb-last');
+      if (i == pathNames.length - 1 ||
+          path == util.GDATA_SEARCH_ROOT_PATH + '/') {
+        div.classList.add('breadcrumb-non-clickable');
       } else {
         div.addEventListener('click', this.onBreadcrumbClick_.bind(this));
+      }
 
+      if (i != pathNames.length - 1) {
         var spacer = doc.createElement('div');
         spacer.className = 'separator';
         bc.appendChild(spacer);
       }
     }
     this.truncateBreadcrumbs_();
   };
 
   FileManager.prototype.isRenamingInProgress = function() {
     return !!this.renameInput_.currentEntry;
@@ skipping 136 matching lines @@
   FileManager.prototype.getCurrentDirectoryURL = function() {
     return this.directoryModel_ &&
         this.directoryModel_.getCurrentDirEntry().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 258 matching lines @@
     }
     if (!this.okButton_.disabled) {
       this.onOk_();
       return true;
     }
     return false;
   };
 
   FileManager.prototype.onDirectoryAction = function(entry) {
     var deviceNumber = this.getDeviceNumber(entry);
+    // TODO(tbarzic): Is this still used?

[SeRya, 2012/05/10 08:44:16]

It's obsolete code. Please remove it.

[tbarzic, 2012/05/10 23:28:02]

Yeah, I though so, but wanted to check before I remove it :)

     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 {
-      return this.directoryModel_.changeDirectory(entry.fullPath);
+      if (!util.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.
+          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) {
@@ skipping 31 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 if needed when directory gets changed.
+   * @param {Entry} oldDirEntry Dir entry from which directory was changed.
+   * @param {Entry} newDirEntry Dir entry to which directory was changed.
+   */
+  FileManager.prototype.updateSearchBoxOnDirChange_ =
+      function(oldDirEntry, newDirEntry) {
+    if (this.directoryModel_.shouldClearSearch(oldDirEntry, newDirEntry))

[SeRya, 2012/05/10 08:44:16]

I think the search box should be cleared unconditionally on each directory
change. In case of search in a local directory keeping searching makes little
sense as well.

[tbarzic, 2012/05/10 23:28:02]

Yeah, I found that a bit strange too, but had decided to keep original
behaviour..

Done.

+      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_(event.previousDirEntry, event.newDirEntry);
 
     // 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 165 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 665 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);
   };
 
   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);
   };
 })();