Change the NaCl loader and broker processes to use the ServiceManager.

content/browser/service_manager/service_manager_context.cc

 // Copyright 2015 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 "content/browser/service_manager/service_manager_context.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 95 matching lines @@
 
 #endif  // ENABLE_MOJO_MEDIA_IN_GPU_PROCESS
 
 // A ManifestProvider which resolves application names to builtin manifest
 // resources for the catalog service to consume.
 class BuiltinManifestProvider : public catalog::ManifestProvider {
  public:
   BuiltinManifestProvider() {}
   ~BuiltinManifestProvider() override {}
 
-  void AddManifestValue(const std::string& name,
-                        std::unique_ptr<base::Value> manifest_contents) {
+  void AddServiceManifest(std::string name, int resource_id) {

[dcheng, 2016/12/19 05:03:25]

If you're feeling ambitious, StringPiece is probably slightly better here (since
a number of inputs come from const char arrays)

[Sam McNally, 2016/12/19 09:36:18]

Done.

+    std::string contents =
+        GetContentClient()
+            ->GetDataResource(resource_id, ui::ScaleFactor::SCALE_FACTOR_NONE)
+            .as_string();
+    DCHECK(!contents.empty());
+
+    std::unique_ptr<base::Value> manifest_value =
+        base::JSONReader::Read(contents);
+    DCHECK(manifest_value);
+
+    std::unique_ptr<base::Value> overlay_value =
+        GetContentClient()->browser()->GetServiceManifestOverlay(name);
+    if (overlay_value) {
+      base::DictionaryValue* manifest_dictionary = nullptr;
+      bool result = manifest_value->GetAsDictionary(&manifest_dictionary);
+      DCHECK(result);
+      base::DictionaryValue* overlay_dictionary = nullptr;
+      result = overlay_value->GetAsDictionary(&overlay_dictionary);
+      DCHECK(result);
+      MergeDictionary(manifest_dictionary, overlay_dictionary);
+    }
+
     auto result = manifests_.insert(
-        std::make_pair(name, std::move(manifest_contents)));
+        std::make_pair(std::move(name), std::move(manifest_value)));
     DCHECK(result.second) << "Duplicate manifest entry: " << name;
   }
 
  private:
   // catalog::ManifestProvider:
   std::unique_ptr<base::Value> GetManifest(const std::string& name) override {
     auto it = manifests_.find(name);
     return it != manifests_.end() ? it->second->CreateDeepCopy() : nullptr;
   }
 
@@ skipping 100 matching lines @@
       { mojom::kBrowserServiceName, IDR_MOJO_CONTENT_BROWSER_MANIFEST },
       { mojom::kGpuServiceName, IDR_MOJO_CONTENT_GPU_MANIFEST },
       { mojom::kPluginServiceName, IDR_MOJO_CONTENT_PLUGIN_MANIFEST },
       { mojom::kRendererServiceName, IDR_MOJO_CONTENT_RENDERER_MANIFEST },
       { mojom::kUtilityServiceName, IDR_MOJO_CONTENT_UTILITY_MANIFEST },
       { catalog::mojom::kServiceName, IDR_MOJO_CATALOG_MANIFEST },
       { file::mojom::kServiceName, IDR_MOJO_FILE_MANIFEST }
     };
 
     for (size_t i = 0; i < arraysize(kManifests); ++i) {
-      std::string contents = GetContentClient()->GetDataResource(
-          kManifests[i].resource_id,
-          ui::ScaleFactor::SCALE_FACTOR_NONE).as_string();
-      base::debug::Alias(&i);
-      CHECK(!contents.empty());
-
-      std::unique_ptr<base::Value> manifest_value =
-          base::JSONReader::Read(contents);
-      base::debug::Alias(&contents);
-      CHECK(manifest_value);
-
-      std::unique_ptr<base::Value> overlay_value =
-          GetContentClient()->browser()->GetServiceManifestOverlay(
-              kManifests[i].name);
-      if (overlay_value) {
-        base::DictionaryValue* manifest_dictionary = nullptr;
-        CHECK(manifest_value->GetAsDictionary(&manifest_dictionary));
-        base::DictionaryValue* overlay_dictionary = nullptr;
-        CHECK(overlay_value->GetAsDictionary(&overlay_dictionary));
-        MergeDictionary(manifest_dictionary, overlay_dictionary);
-      }
-
-      manifest_provider->AddManifestValue(kManifests[i].name,
-                                          std::move(manifest_value));
+      manifest_provider->AddServiceManifest(kManifests[i].name,
+                                            kManifests[i].resource_id);
+    }
+    for (const auto& manifest :
+         GetContentClient()->browser()->GetExtraServiceManifests()) {
+      manifest_provider->AddServiceManifest(std::move(manifest.name),
+                                            manifest.resource_id);
     }
     in_process_context_ = new InProcessServiceManagerContext;
     request = in_process_context_->Start(std::move(manifest_provider));
   }
   ServiceManagerConnection::SetForProcess(ServiceManagerConnection::Create(
       std::move(request),
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 
   ContentBrowserClient::StaticServiceMap services;
   GetContentClient()->browser()->RegisterInProcessServices(&services);
@@ skipping 51 matching lines @@
                           base::Bind(&DestroyConnectorOnIOThread));
 }
 
 // static
 service_manager::Connector* ServiceManagerContext::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return g_io_thread_connector.Get().get();
 }
 
 }  // namespace content