file_manager: getFileTasks() to return Drive apps iff all files are on Drive

chrome/browser/chromeos/extensions/file_manager/file_tasks_unittest.cc

 // Copyright 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.
 
 #include "chrome/browser/chromeos/extensions/file_manager/file_tasks.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/drive/drive_app_registry.h"
+#include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/app_id.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace file_manager {
 namespace file_tasks {
 namespace {
 
@@ skipping 38 matching lines @@
   EXPECT_EQ("app-id|file|action-id", task_id);
 
   std::string icon_url;
   EXPECT_TRUE(dictionary->GetString("iconUrl", &icon_url));
   EXPECT_EQ("http://example.com/icon.png", icon_url);
 
   std::string title;
   EXPECT_TRUE(dictionary->GetString("title", &title));
   EXPECT_EQ("task title", title);
 
-  bool is_drive_app = false;
-  EXPECT_TRUE(dictionary->GetBoolean("driveApp", &is_drive_app));
-  EXPECT_FALSE(is_drive_app);
-
   bool is_default = false;
   EXPECT_TRUE(dictionary->GetBoolean("isDefault", &is_default));
   EXPECT_TRUE(is_default);
 }
 
 TEST(FileManagerFileTasksTest,
      FullTaskDescriptor_DriveAppWithoutIconAndNotDefault) {
   FullTaskDescriptor full_descriptor(
       TaskDescriptor("app-id",
                      TASK_TYPE_DRIVE_APP,
                      "action-id"),
       "task title",
       GURL(),  // No icon URL.
       false /* is_default */);
 
   scoped_ptr<base::DictionaryValue> dictionary(
       full_descriptor.AsDictionaryValue());
   std::string task_id;
   EXPECT_TRUE(dictionary->GetString("taskId", &task_id));
   EXPECT_EQ("app-id|drive|action-id", task_id);
 
   std::string icon_url;
   EXPECT_FALSE(dictionary->GetString("iconUrl", &icon_url));
 
   std::string title;
   EXPECT_TRUE(dictionary->GetString("title", &title));
   EXPECT_EQ("task title", title);
 
-  bool is_drive_app = false;
-  EXPECT_TRUE(dictionary->GetBoolean("driveApp", &is_drive_app));
-  EXPECT_TRUE(is_drive_app);
-
   bool is_default = false;
   EXPECT_TRUE(dictionary->GetBoolean("isDefault", &is_default));
   EXPECT_FALSE(is_default);
 }
 
 TEST(FileManagerFileTasksTest, MakeTaskID) {
   EXPECT_EQ("app-id|file|action-id",
             MakeTaskID("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"));
   EXPECT_EQ("app-id|app|action-id",
             MakeTaskID("app-id", TASK_TYPE_FILE_HANDLER, "action-id"));
@@ skipping 98 matching lines @@
   app_resources.push_back(foo_app.release());
   app_resources.push_back(bar_app.release());
   google_apis::AppList app_list;
   app_list.set_items(&app_resources);
   drive::DriveAppRegistry drive_app_registry(NULL);
   drive_app_registry.UpdateFromAppList(app_list);
 
   // Find apps for a "text/plain" file. Foo.app and Bar.app should be found.
   PathAndMimeTypeSet path_mime_set;
   path_mime_set.insert(
-      std::make_pair(base::FilePath::FromUTF8Unsafe("foo.txt"), "text/plain"));
+      std::make_pair(
+          drive::util::GetDriveMountPointPath().AppendASCII("foo.txt"),
+          "text/plain"));
   std::vector<FullTaskDescriptor> tasks;
   FindDriveAppTasks(drive_app_registry,
                     path_mime_set,
                     &tasks);
   ASSERT_EQ(2U, tasks.size());
   // Sort the app IDs, as the order is not guaranteed.
   std::vector<std::string> app_ids;
   app_ids.push_back(tasks[0].task_descriptor().app_id);
   app_ids.push_back(tasks[1].task_descriptor().app_id);
   std::sort(app_ids.begin(), app_ids.end());
   // Confirm that both Foo.app and Bar.app are found.
   EXPECT_EQ("bar_app_id", app_ids[0]);
   EXPECT_EQ("foo_app_id", app_ids[1]);
 
   // Find apps for "text/plain" and "text/html" files. Only Foo.app should be
   // found.
   path_mime_set.clear();
   path_mime_set.insert(
-      std::make_pair(base::FilePath::FromUTF8Unsafe("foo.txt"), "text/plain"));
+      std::make_pair(
+          drive::util::GetDriveMountPointPath().AppendASCII("foo.txt"),
+          "text/plain"));
   path_mime_set.insert(
-      std::make_pair(base::FilePath::FromUTF8Unsafe("foo.html"), "text/html"));
+      std::make_pair(
+          drive::util::GetDriveMountPointPath().AppendASCII("foo.html"),
+          "text/html"));
   tasks.clear();
   FindDriveAppTasks(drive_app_registry,
                     path_mime_set,
                     &tasks);
   ASSERT_EQ(1U, tasks.size());
   // Confirm that both Foo.app is found.
   EXPECT_EQ("foo_app_id", tasks[0].task_descriptor().app_id);
+
+  // Add a "text/plain" file not on Drive. No tasks should be found.
+  path_mime_set.insert(
+      std::make_pair(base::FilePath::FromUTF8Unsafe("not_on_drive.txt"),
+                     "text/plain"));
+  tasks.clear();
+  FindDriveAppTasks(drive_app_registry,
+                    path_mime_set,
+                    &tasks);
+  // Confirm no tasks are found.
+  ASSERT_TRUE(tasks.empty());
 }
 
 // Test that the right task is chosen from multiple choices per mime types
 // and file extensions.
 TEST(FileManagerFileTasksTest, ChooseAndSetDefaultTask_MultipleTasks) {
   TestingPrefServiceSimple pref_service;
   RegisterDefaultTaskPreferences(&pref_service);
 
   // Text.app and Nice.app were found for "foo.txt".
   TaskDescriptor text_app_task("text-app-id",
@@ skipping 81 matching lines @@
       "text/plain"));
 
   // The internal file browser handler should be chosen as default, as it's a
   // fallback file browser handler.
   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
   EXPECT_TRUE(tasks[0].is_default());
 }
 
 }  // namespace file_tasks
 }  // namespace file_manager.