Get rid of the fake Drive/root entry.

chrome/browser/resources/file_manager/foreground/js/directory_tree.js

 // Copyright (c) 2013 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.
 
 'use strict';
 
 ////////////////////////////////////////////////////////////////////////////////
 // DirectoryTreeUtil
 
 /**
@@ skipping 32 matching lines @@
  * @param {boolean} recursive True if the all visible sub-directories are
  *     updated recursively including left arrows. If false, the update walks
  *     only immediate child directories without arrows.
  */
 DirectoryItemTreeBaseMethods.updateSubElementsFromList = function(recursive) {
   var index = 0;
   var tree = this.parentTree_ || this;  // If no parent, 'this' itself is tree.
   while (this.entries_[index]) {
     var currentEntry = this.entries_[index];
     var currentElement = this.items[index];
+    // TODO(mtomasz): Stop using full paths, and use getLocationInfo() instead.
+    var label = PathUtil.getFolderLabel(currentEntry.fullPath);
 
     if (index >= this.items.length) {
-      var item = new DirectoryItem(currentEntry, this, tree);
+      var item = new DirectoryItem(label, currentEntry, this, tree);
       this.add(item);
       index++;
     } else if (currentEntry.fullPath == currentElement.fullPath) {
       if (recursive && this.expanded)
         currentElement.updateSubDirectories(true /* recursive */);
 
       index++;
     } else if (currentEntry.fullPath < currentElement.fullPath) {
-      var item = new DirectoryItem(currentEntry, this, tree);
+      var item = new DirectoryItem(label, currentEntry, this, tree);
       this.addAt(item, index);
       index++;
     } else if (currentEntry.fullPath > currentElement.fullPath) {
       this.remove(currentElement);
     }
   }
 
   var removedChild;
   while (removedChild = this.items[index]) {
     this.remove(removedChild);
@@ skipping 27 matching lines @@
 };
 
 Object.freeze(DirectoryItemTreeBaseMethods);
 
 ////////////////////////////////////////////////////////////////////////////////
 // DirectoryItem
 
 /**
  * A directory in the tree. Each element represents one directory.
  *
+ * @param {string} label Label for this item.
  * @param {DirectoryEntry} dirEntry DirectoryEntry of this item.
  * @param {DirectoryItem|DirectoryTree} parentDirItem Parent of this item.
  * @param {DirectoryTree} tree Current tree, which contains this item.
  * @extends {cr.ui.TreeItem}
  * @constructor
  */
-function DirectoryItem(dirEntry, parentDirItem, tree) {
+function DirectoryItem(label, dirEntry, parentDirItem, tree) {
   var item = cr.doc.createElement('div');
-  DirectoryItem.decorate(item, dirEntry, parentDirItem, tree);
+  DirectoryItem.decorate(item, label, dirEntry, parentDirItem, tree);
   return item;
 }
 
 /**
  * @param {HTMLElement} el Element to be DirectoryItem.
+ * @param {string} label Label for this item.
  * @param {DirectoryEntry} dirEntry DirectoryEntry of this item.
  * @param {DirectoryItem|DirectoryTree} parentDirItem Parent of this item.
  * @param {DirectoryTree} tree Current tree, which contains this item.
  */
 DirectoryItem.decorate =
-    function(el, dirEntry, parentDirItem, tree) {
+    function(el, label, dirEntry, parentDirItem, tree) {
   el.__proto__ = DirectoryItem.prototype;
   (/** @type {DirectoryItem} */ el).decorate(
-      dirEntry, parentDirItem, tree);
+      label, dirEntry, parentDirItem, tree);
 };
 
 DirectoryItem.prototype = {
   __proto__: cr.ui.TreeItem.prototype,
 
   /**
    * The DirectoryEntry corresponding to this DirectoryItem. This may be
    * a dummy DirectoryEntry.
    * @type {DirectoryEntry|Object}
    */
@@ skipping 26 matching lines @@
  * Calls DirectoryItemTreeBaseMethods.updateSubElementsFromList().
  * @param {DirectoryEntry|Object} entry The entry to be searched for. Can be
  *     a fake.
  * @return {boolean} True if the parent item is found.
  */
 DirectoryItem.prototype.searchAndSelectByEntry = function(entry) {
   return DirectoryItemTreeBaseMethods.searchAndSelectByEntry.call(this, entry);
 };
 
 /**
+ * @param {string} label Localized label for this item.
  * @param {DirectoryEntry} dirEntry DirectoryEntry of this item.
  * @param {DirectoryItem|DirectoryTree} parentDirItem Parent of this item.
  * @param {DirectoryTree} tree Current tree, which contains this item.
  */
 DirectoryItem.prototype.decorate = function(
-    dirEntry, parentDirItem, tree) {
+    label, dirEntry, parentDirItem, tree) {
   this.className = 'tree-item';
   this.innerHTML =
       '<div class="tree-row">' +
       ' <span class="expand-icon"></span>' +
       ' <span class="icon"></span>' +
       ' <span class="label"></span>' +
       '</div>' +
       '<div class="tree-children"></div>';
   this.setAttribute('role', 'treeitem');
 
   this.parentTree_ = tree;
   this.directoryModel_ = tree.directoryModel;
   this.parent_ = parentDirItem;
-  this.label = dirEntry.label || dirEntry.name;
+  this.label = label;
   this.fullPath = dirEntry.fullPath;
   this.dirEntry_ = dirEntry;
   this.fileFilter_ = this.directoryModel_.getFileFilter();
 
   // Sets hasChildren=false tentatively. This will be overridden after
   // scanning sub-directories in DirectoryTreeUtil.updateSubElementsFromList.
   this.hasChildren = false;
 
   this.addEventListener('expand', this.onExpand_.bind(this), false);
   var icon = this.querySelector('.icon');
@@ skipping 293 matching lines @@
     }
   }.bind(this));
 
   this.privateOnDirectoryChangedBound_ =
       this.onDirectoryContentChanged_.bind(this);
   chrome.fileBrowserPrivate.onDirectoryChanged.addListener(
       this.privateOnDirectoryChangedBound_);
 
   this.scrollBar_ = MainPanelScrollBar();
   this.scrollBar_.initialize(this.parentNode, this);
-
-  // Once, draws the list with the fake '/drive/' entry.
-  this.redraw(false /* recursive */);
-  // Resolves 'My Drive' entry and replaces the fake with the true one.
-  this.maybeResolveMyDriveRoot_(function() {
-    // After the true entry is resolved, draws the list again.
-    this.redraw(true /* recursive */);
-  }.bind(this));
 };
 
 /**
  * Select the item corresponding to the given entry.
  * @param {DirectoryEntry|Object} entry The directory entry to be selected. Can
  *     be a fake.
  */
 DirectoryTree.prototype.selectByEntry = function(entry) {
   // If the target directory is not in the tree, do nothing.
   if (!DirectoryTreeUtil.isEligiblePathForDirectoryTree(entry.fullPath))
     return;
 
-  this.maybeResolveMyDriveRoot_(function() {
-    if (this.selectedItem && util.isSameEntry(entry, this.selectedItem.entry))
-      return;
+  var volumeInfo = this.volumeManager_.getVolumeInfo(entry);
+  if (this.selectedItem && util.isSameEntry(entry, this.selectedItem.entry))
+    return;
 
-    if (this.searchAndSelectByEntry(entry))
-      return;
+  if (this.searchAndSelectByEntry(entry))
+    return;
 
-    this.selectedItem = null;
-    this.updateSubDirectories(
-        false /* recursive */,
-        // Success callback, failure is not handled.
-        function() {
-          if (!this.searchAndSelectByEntry(entry))
-            this.selectedItem = null;
-        }.bind(this));
+  this.updateSubDirectories(false /* recursive */);
+  // TODO(yoshiki, mtomasz): There may be a race in here.
+  volumeInfo.resolveDisplayRoot(function() {
+    if (!this.searchAndSelectByEntry(entry))
+        this.selectedItem = null;
   }.bind(this));
 };
 
 /**
- * Resolves the My Drive root's entry, if it is a fake. If the entry is already
- * resolved to a DirectoryEntry, completionCallback() will be called
- * immediately.
- * @param {function()} completionCallback Called when the resolving is
- *     done (or the entry is already resolved), regardless if it is
- *     successfully done or not.
- * @private
+ * Retrieves the latest subdirectories and update them on the tree.
+ *
+ * @param {boolean} recursive True if the update is recursively.
+ * @param {function()=} opt_callback Called when subdirectories are fully
+ *     updated.
  */
-DirectoryTree.prototype.maybeResolveMyDriveRoot_ = function(
-    completionCallback) {
-  var myDriveItem = this.items[0];
-  if (!myDriveItem || !util.isFakeEntry(myDriveItem.entry)) {
-    // The entry is already resolved. Don't need to try again.
-    completionCallback();
-    return;
+DirectoryTree.prototype.updateSubDirectories = function(

[yoshiki, 2014/01/15 07:33:13]

Could you change the method name? Or change the name of
DirectoryItem.updateSubDirectories? Before they were same name and had same
interface, but now not. Different name is better to prevent confusion.

[mtomasz, 2014/01/16 01:31:58]

There is no defined interface @interface, not this method has @override, so I
think it is not so confusing. I think both methods do exactly the same, just
different way, so I think having the same method name is legit to me. WDYT?

[yoshiki, 2014/01/17 01:57:52]

OK. I agree with you.

+    recursive, opt_callback) {
+  var callback = opt_callback || function() {};
+  this.entries_ = [];
+
+  var compareEntries = function(a, b) {
+    return a.toURL() < b.toURL();
+  };
+
+  // Add fakes (if any).
+  for (var key in this.currentVolumeInfo_.fakeEntries) {
+    this.entries_.push(this.currentVolumeInfo_.fakeEntries[key]);
   }
 
-  // The entry is a fake.
-  this.directoryModel_.resolveDirectory(
-      myDriveItem.fullPath,
-      function(entry) {
-        if (!util.isFakeEntry(entry))
-          myDriveItem.dirEntry_ = entry;
+  // If the display root is not available yet, then redraw anyway with what
+  // we have. However, concurrently try to resolve the display root and then
+  // redraw.
+  if (!this.currentVolumeInfo_.displayRoot) {
+    this.entries_.sort(compareEntries);
+    this.redraw(recursive);
+  }
 
-        completionCallback();
-      },
-      completionCallback);
+  this.currentVolumeInfo_.resolveDisplayRoot(function(displayRoot) {
+    this.entries_.push(this.currentVolumeInfo_.displayRoot);
+    this.entries_.sort(compareEntries);
+    this.redraw(recursive);  // Redraw.
+    callback();
+  }.bind(this), callback /* Ignore errors. */);
 };
 
 /**
- * Retrieves the latest subdirectories and update them on the tree.
- * @param {boolean} recursive True if the update is recursively.
- * @param {function()=} opt_successCallback Callback called on success.
- * @param {function()=} opt_errorCallback Callback called on error.
- */
-DirectoryTree.prototype.updateSubDirectories = function(
-    recursive, opt_successCallback, opt_errorCallback) {
-  var hasFakeEntries = this.currentVolumeInfo_ &&
-      this.currentVolumeInfo_.volumeType === util.VolumeType.DRIVE;
-  this.entries_ = hasFakeEntries ? [
-    this.currentVolumeInfo_.fakeEntries[RootType.DRIVE],
-    this.currentVolumeInfo_.fakeEntries[RootType.DRIVE_OFFLINE],
-    this.currentVolumeInfo_.fakeEntries[RootType.DRIVE_SHARED_WITH_ME],
-    this.currentVolumeInfo_.fakeEntries[RootType.DRIVE_RECENT]
-  ] : [];
-
-  this.redraw(recursive);
-  if (opt_successCallback)
-    opt_successCallback();
-};
-
-/**
  * Redraw the list.
  * @param {boolean} recursive True if the update is recursively. False if the
  *     only root items are updated.
  */
 DirectoryTree.prototype.redraw = function(recursive) {
   this.updateSubElementsFromList(recursive);
 };
 
 /**
  * Invoked when the filter is changed.
@@ skipping 45 matching lines @@
   this.style.paddingBottom = margin + 'px';
   this.scrollBar_.setBottomMarginForPanel(margin);
 };
 
 /**
  * Updates the UI after the layout has changed.
  */
 DirectoryTree.prototype.relayout = function() {
   cr.dispatchSimpleEvent(this, 'relayout');
 };