Add inline completion to quicklaunch

mojo/services/catalog/catalog.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 "mojo/services/catalog/catalog.h"
 
 #include "base/bind.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/strings/string_split.h"
 #include "base/task_runner_util.h"
@@ skipping 47 matching lines @@
   int error = 0;
   std::string message;
   // TODO(beng): probably want to do more detailed error checking. This should
   //             be done when figuring out if to unblock connection completion.
   scoped_ptr<ReadManifestResult> result(new ReadManifestResult);
   result->manifest_root = deserializer.Deserialize(&error, &message);
   result->package_dir = system_package_dir;
   return result;
 }
 
+void AddEntryToMap(const Entry& entry,
+                   mojo::Map<mojo::String, mojom::CatalogEntryPtr>* map) {
+  mojom::CatalogEntryPtr entry_ptr(mojom::CatalogEntry::New());
+  entry_ptr->display_name = entry.display_name();
+  (*map)[entry.name()] = std::move(entry_ptr);
+}
+
 }  // namespace
 
 ReadManifestResult::ReadManifestResult() {}
 ReadManifestResult::~ReadManifestResult() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Catalog, public:
 
 Catalog::Catalog(scoped_ptr<Store> store,
                  base::TaskRunner* file_task_runner,
@@ skipping 74 matching lines @@
       base::Bind(&Catalog::OnReadManifest, weak_factory_.GetWeakPtr(),
                   mojo_name, callback));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Catalog, mojom::Catalog:
 
 void Catalog::GetEntries(mojo::Array<mojo::String> names,
                          const GetEntriesCallback& callback) {
   mojo::Map<mojo::String, mojom::CatalogEntryPtr> entries;
-  std::vector<mojo::String> names_vec = names.PassStorage();
-  for (const std::string& name : names_vec) {
-    Entry* entry = nullptr;
-    if (user_catalog_.find(name) != user_catalog_.end())
-      entry = user_catalog_[name].get();
-    else if (system_catalog_->find(name) != system_catalog_->end())
-      entry = (*system_catalog_)[name].get();
-    else
-      continue;
-    mojom::CatalogEntryPtr entry_ptr(mojom::CatalogEntry::New());
-    entry_ptr->display_name = entry->display_name();
-    entries[entry->name()] = std::move(entry_ptr);
+  if (names.is_null()) {
+    for (const auto& entry : user_catalog_)
+      AddEntryToMap(*entry.second, &entries);
+    for (const auto& entry : *system_catalog_)
+      AddEntryToMap(*entry.second, &entries);
+  } else {
+    std::vector<mojo::String> names_vec = names.PassStorage();
+    for (const std::string& name : names_vec) {
+      Entry* entry = nullptr;
+      if (user_catalog_.find(name) != user_catalog_.end())
+        entry = user_catalog_[name].get();
+      else if (system_catalog_->find(name) != system_catalog_->end())
+        entry = (*system_catalog_)[name].get();
+      else
+        continue;
+      AddEntryToMap(*entry, &entries);
+    }
   }
   callback.Run(std::move(entries));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Catalog, private:
 
 void Catalog::DeserializeCatalog() {
   if (!store_)
     return;
@@ skipping 29 matching lines @@
   if (result->manifest_root) {
     const base::DictionaryValue* dictionary = nullptr;
     CHECK(result->manifest_root->GetAsDictionary(&dictionary));
     entry = Entry::Deserialize(*dictionary);
   }
   entry->set_path(GetPackagePath(result->package_dir, name));
 
   callback.Run(mojo::shell::mojom::ResolveResult::From(*entry));
   if (catalog) {
     catalog->AddEntryToCatalog(
-       std::move(entry),
-        result->package_dir == catalog->system_package_dir_);
+        std::move(entry), result->package_dir == catalog->system_package_dir_);
   }
 }
 
 void Catalog::AddEntryToCatalog(scoped_ptr<Entry> entry,
                                 bool is_system_catalog) {
   DCHECK(entry);
   EntryCache* catalog = is_system_catalog ? system_catalog_ : &user_catalog_;
   if (catalog->end() != catalog->find(entry->name()))
     return;
   for (auto child : entry->applications())
     AddEntryToCatalog(make_scoped_ptr(child), is_system_catalog);
   (*catalog)[entry->name()] = std::move(entry);
   SerializeCatalog();
 }
 
 }  // namespace catalog