Defer ARC file system operations while ARC is booting.

chrome/browser/chromeos/arc/fileapi/arc_documents_provider_root_unittest.cc

 // Copyright 2016 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 <string.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/arc/fileapi/arc_documents_provider_root.h"
 #include "chrome/browser/chromeos/arc/fileapi/arc_documents_provider_util.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
-#include "components/arc/test/fake_file_system_instance.h"
+#include "components/arc/file_system/test/fake_arc_file_system_operation_runner.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "storage/common/fileapi/directory_entry.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using storage::DirectoryEntry;
 using EntryList = storage::AsyncFileUtil::EntryList;
 
 namespace arc {
 
@@ skipping 13 matching lines @@
 // (root)/           dir         root-id
 //   dir/            dir         dir-id
 //     photo.jpg     image/jpeg  photo-id
 //     music.bin     audio/mp3   music-id
 //   dups/           dir         dups-id
 //     dup.mp4       video/mp4   dup1-id
 //     dup.mp4       video/mp4   dup2-id
 //     dup.mp4       video/mp4   dup3-id
 //     dup.mp4       video/mp4   dup4-id
 constexpr char kAuthority[] = "org.chromium.test";
-constexpr DocumentSpec kRootSpec = {"root-id", "(root)",
-                                    kAndroidDirectoryMimeType, -1, 11};
+// NOTE: ArcDocumentsProviderRoot::GetFileInfo() returns hard-coded info
+// for root documents.
+constexpr DocumentSpec kRootSpec = {"root-id", nullptr /* not used */,
+                                    kAndroidDirectoryMimeType, -1, 0};
 constexpr DocumentSpec kDirSpec = {"dir-id", "dir", kAndroidDirectoryMimeType,
                                    -1, 22};
 constexpr DocumentSpec kPhotoSpec = {"photo-id", "photo.jpg", "image/jpeg", 3,
                                      33};
 constexpr DocumentSpec kMusicSpec = {"music-id", "music.bin", "audio/mp3", 4,
                                      44};
 constexpr DocumentSpec kDupsSpec = {"dups-id", "dups",
                                     kAndroidDirectoryMimeType, -1, 55};
 constexpr DocumentSpec kDup1Spec = {"dup1-id", "dup.mp4", "video/mp4", 6, 66};
 constexpr DocumentSpec kDup2Spec = {"dup2-id", "dup.mp4", "video/mp4", 7, 77};
 constexpr DocumentSpec kDup3Spec = {"dup3-id", "dup.mp4", "video/mp4", 8, 88};
 constexpr DocumentSpec kDup4Spec = {"dup4-id", "dup.mp4", "video/mp4", 9, 99};
 constexpr DocumentSpec kAllSpecs[] = {kRootSpec,  kDirSpec,  kPhotoSpec,
                                       kMusicSpec, kDupsSpec, kDup1Spec,
                                       kDup2Spec,  kDup3Spec, kDup4Spec};
 
 mojom::DocumentPtr MakeDocument(const DocumentSpec& spec) {
   mojom::DocumentPtr document = mojom::Document::New();
   document->document_id = spec.document_id;
   document->display_name = spec.display_name;
   document->mime_type = spec.mime_type;
   document->size = spec.size;
   document->last_modified = spec.last_modified;
   return document;
 }
 
-class FileSystemInstanceTestImpl : public FakeFileSystemInstance {
+// TODO(crbug.com/683049): Use a generic FakeArcFileSystemOperationRunner.
+class ArcFileSystemOperationRunnerForTest
+    : public FakeArcFileSystemOperationRunner {
  public:
+  explicit ArcFileSystemOperationRunnerForTest(ArcBridgeService* bridge_service)
+      : FakeArcFileSystemOperationRunner(bridge_service) {}
+  ~ArcFileSystemOperationRunnerForTest() override = default;
+
   void GetChildDocuments(const std::string& authority,
                          const std::string& document_id,
                          const GetChildDocumentsCallback& callback) override {
     EXPECT_EQ(kAuthority, authority);
     base::Optional<std::vector<mojom::DocumentPtr>> result;
     if (document_id == kRootSpec.document_id) {
       result.emplace();
       result.value().emplace_back(MakeDocument(kDirSpec));
       result.value().emplace_back(MakeDocument(kDupsSpec));
     } else if (document_id == kDirSpec.document_id) {
@@ skipping 42 matching lines @@
             static_cast<uint64_t>(info.creation_time.ToJavaTime()));
 }
 
 class ArcDocumentsProviderRootTest : public testing::Test {
  public:
   ArcDocumentsProviderRootTest()
       : arc_service_manager_(base::MakeUnique<ArcServiceManager>(nullptr)),
         root_(
             base::MakeUnique<ArcDocumentsProviderRoot>(kAuthority,
                                                        kRootSpec.document_id)) {
-    arc_service_manager_->arc_bridge_service()->file_system()->SetInstance(
-        &file_system_);
+    arc_service_manager_->AddService(
+        base::MakeUnique<ArcFileSystemOperationRunnerForTest>(
+            arc_service_manager_->arc_bridge_service()));
   }
 
   ~ArcDocumentsProviderRootTest() override = default;
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
-  FileSystemInstanceTestImpl file_system_;
   std::unique_ptr<ArcServiceManager> arc_service_manager_;
   std::unique_ptr<ArcDocumentsProviderRoot> root_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcDocumentsProviderRootTest);
 };
 
 }  // namespace
 
 TEST_F(ArcDocumentsProviderRootTest, GetFileInfo) {
@@ skipping 197 matching lines @@
           [](base::RunLoop* run_loop, const GURL& url) {
             EXPECT_EQ(GURL("content://org.chromium.test/document/dup3-id"),
                       url);
             run_loop->Quit();
           },
           &run_loop));
   run_loop.Run();
 }
 
 }  // namespace arc