Fixes race in Shell

services/catalog/reader.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 "services/catalog/reader.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
@@ skipping 122 matching lines @@
 void AddEntryToCache(EntryCache* cache, std::unique_ptr<Entry> entry) {
   for (auto child : entry->applications())
     AddEntryToCache(cache, base::WrapUnique(child));
   (*cache)[entry->name()] = std::move(entry);
 }
 
 void DoNothing(shell::mojom::ResolveResultPtr) {}
 
 }  // namespace
 
-Reader::Reader(base::TaskRunner* file_task_runner,
+// A sequenced task runner is used to guarantee requests are serviced in the
+// order requested. To do otherwise means we may run callbacks in an
+// unpredictable order, leading to flake.
+Reader::Reader(base::SequencedWorkerPool* worker_pool,
                ManifestProvider* manifest_provider)
-    : file_task_runner_(file_task_runner),
-      manifest_provider_(manifest_provider),
-      weak_factory_(this) {
-  PathService::Get(base::DIR_MODULE, &system_package_dir_);
+    : Reader(manifest_provider) {
+  file_task_runner_ = worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
+      base::SequencedWorkerPool::GetSequenceToken(),
+      base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 }
+
+Reader::Reader(base::SingleThreadTaskRunner* task_runner,
+               ManifestProvider* manifest_provider)
+    : Reader(manifest_provider) {
+  file_task_runner_ = task_runner;
+}
+
 Reader::~Reader() {}
 
 void Reader::Read(const base::FilePath& package_dir,
                   EntryCache* cache,
                   const base::Closure& read_complete_closure) {
   file_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ScanDir, package_dir,
                  base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(),
                             cache, base::Bind(&DoNothing)),
                  base::ThreadTaskRunnerHandle::Get(),
                  read_complete_closure));
 }
 
 void Reader::CreateEntryForName(
     const std::string& mojo_name,
     EntryCache* cache,
     const CreateEntryForNameCallback& entry_created_callback) {
   std::string manifest_contents;
   if (manifest_provider_ &&
       manifest_provider_->GetApplicationManifest(mojo_name,
                                                  &manifest_contents)) {
     std::unique_ptr<base::Value> manifest_root =
         base::JSONReader::Read(manifest_contents);
     base::PostTaskAndReplyWithResult(
-        file_task_runner_, FROM_HERE,
+        file_task_runner_.get(), FROM_HERE,
         base::Bind(&ProcessManifest, base::Passed(&manifest_root),
                    system_package_dir_),
-        base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(),
-                   cache, entry_created_callback));
+        base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), cache,
+                   entry_created_callback));
   } else {
     base::PostTaskAndReplyWithResult(
-        file_task_runner_, FROM_HERE,
+        file_task_runner_.get(), FROM_HERE,
         base::Bind(&ReadManifest, system_package_dir_, mojo_name),
-        base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(),
-                   cache, entry_created_callback));
+        base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), cache,
+                   entry_created_callback));
   }
 }
 
+Reader::Reader(ManifestProvider* manifest_provider)
+    : manifest_provider_(manifest_provider), weak_factory_(this) {
+  PathService::Get(base::DIR_MODULE, &system_package_dir_);
+}
+
 void Reader::OnReadManifest(
     EntryCache* cache,
     const CreateEntryForNameCallback& entry_created_callback,
     std::unique_ptr<Entry> entry) {
   shell::mojom::ResolveResultPtr result =
       shell::mojom::ResolveResult::From(*entry);
   AddEntryToCache(cache, std::move(entry));
   entry_created_callback.Run(std::move(result));
 }
 
 }  // namespace catalog