Move view change analytics tracking into DirectoryModel where implementation details can be hidden.

ui/file_manager/file_manager/common/js/importer_common.js

 // Copyright 2014 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.
 
 // Shared cloud importer namespace
 var importer = importer || {};
 
 /** @enum {string} */
 importer.ScanEvent = {
   FINALIZED: 'finalized',
@@ skipping 179 matching lines @@
   // valid import root.
   if (splitPath[0] in importer.ValidImportRoots_ && splitPath.length === 1) {
     console.assert(volumeInfoProvider !== null);
     var volumeInfo = volumeInfoProvider.getVolumeInfo(entry);
     return importer.isEligibleVolume(volumeInfo);
   }
   return false;
 };
 
 /**
+ * @param {!DirectoryEntry} directory Presumably the root of a filesystem.
+ * @return {!Promise<boolean>} True if the directory contains a
+ *     child media directory (like 'DCIM').
+ */
+importer.hasMediaDirectory = function(directory) {
+  /**
+   * @param {boolean} answer
+   * @return {boolean}
+   */
+  var isTrue = function(answer) {
+    return answer;
+  };
+  var dirNames = Object.keys(importer.ValidImportRoots_);
+  return Promise.all(dirNames.map(importer.hasDirectory_.bind(null, directory)))
+      .then(
+          /**
+           * @param {!Array<boolean>} results
+           * @return {!Promise<boolean>}
+           */
+          function(results) {
+            if (results.some(isTrue)) {
+              return Promise.resolve(true);
+            } else {
+              // If standard (upper case) forms are not present,
+              // check for a lower-case "DCIM".
+              return importer.hasDirectory_(directory, 'dcim');
+            }
+          });
+};
+
+/**
+ * @param {!DirectoryEntry} parent
+ * @param {string} name
+ * @return {!Promise<boolean>} True if parent contains a directory
+ *     with the specified name.
+ * @private
+ */
+importer.hasDirectory_ = function(parent, name) {
+  return importer.getDirectory_(parent, name)
+      .then(
+          function() {
+            return true;
+          },
+          function() {
+            return false;
+          });
+};
+
+/**
+ * @param {!DirectoryEntry} parent
+ * @param {string} name
+ * @return {!Promise<!DirectoryEntry>}
+ * @private
+ */
+importer.getDirectory_ = function(parent, name) {
+  return new Promise(
+    function(resolve, reject) {
+      parent.getDirectory(
+          name,
+          {
+            create: false,
+            exclusive: false
+          },
+          resolve,
+          reject);
+    });
+};
+
+/**
  * @return {!Promise<boolean>} Resolves with true when Cloud Import feature
  *     is enabled.
  */
 importer.importEnabled = function() {
   return new Promise(
       function(resolve, reject) {
         chrome.commandLinePrivate.hasSwitch(
             'disable-cloud-import',
             /** @param {boolean} disabled */
             function(disabled) {
@@ skipping 112 matching lines @@
  * @return {!Promise<!FileEntry>} all history files not having
  *     a machine id matching {@code machineId}.
  * @private
  */
 importer.getUnownedHistoryFiles_ = function(machineId) {
   var historyFiles = [];
   return importer.ChromeSyncFilesystem.getRoot()
       .then(
           /** @param {!DirectoryEntry} root */
           function(root) {
-            return fileOperationUtil.listEntries(
+            return importer.listEntries_(
                 root,
                 /** @param {Entry} entry */
                 function(entry) {
                   if (entry.isFile &&
                       entry.name.indexOf(machineId.toString()) === -1 &&
                       /^([0-9]{6}-import-history.log)$/.test(entry.name)) {
                     historyFiles.push(/** @type {!FileEntry} */ (entry));
                   }
                 })
                 .then(
@@ skipping 25 matching lines @@
     ]).then(
         /** @param {!Array<!FileEntry|!Array<!FileEntry>>} entries */
         function(entries) {
           var historyFiles = entries[1];
           historyFiles.unshift(entries[0]);
           return historyFiles;
         });
 };
 
 /**
+ * Calls {@code callback} for each child entry of {@code directory}.
+ *
+ * @param {!DirectoryEntry} directory
+ * @param {function(!Entry)} callback
+ * @return {!Promise} Resolves when listing is complete.
+ * @private
+ */
+importer.listEntries_ = function(directory, callback) {
+  return new Promise(
+      function(resolve, reject) {
+        var reader = directory.createReader();
+
+        var readEntries = function() {
+          reader.readEntries (
+              /** @param {!Array<!Entry>} entries */
+              function(entries) {
+                if (entries.length === 0) {
+                  resolve(undefined);
+                  return;
+                }
+                entries.forEach(callback);
+                readEntries();
+              },
+              reject);
+        };
+
+        readEntries();
+      });
+};
+
+/**
  * A Promise wrapper that provides public access to resolve and reject methods.
  *
  * @constructor
  * @struct
  * @template T
  */
 importer.Resolver = function() {
   /** @private {boolean} */
   this.settled_ = false;
 
@@ skipping 270 matching lines @@
                       function(resolve, reject) {
                         directory.getFile(
                             fileName,
                             {
                               create: true,
                               exclusive: false
                             },
                             resolve,
                             reject);
                       });
-
                 });
           });
 
   return /** @type {!Promise<!FileEntry>} */ (promise);
 };
 
 /**
  * A basic logging mechanism.
  *
  * @interface
@@ skipping 313 matching lines @@
       });
 };
 
 /** @private @const {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.INSTANCE_ = new importer.ChromeLocalStorage();
 
 /** @return {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.getInstance = function() {
   return importer.ChromeLocalStorage.INSTANCE_;
 };