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 97 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) {
+    std::string contents =
+        GetContentClient()
+            ->GetDataResource(resource_id, ui::ScaleFactor::SCALE_FACTOR_NONE)
+            .as_string();
+    CHECK(!contents.empty());

[piman, 2016/11/28 23:04:37]

If these are to investigate a bug, please document which (open) bug it is, so
that they can be reverted to DCHECKs (and debug::Alias removed) once the bug is
fixed, as per
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...
(these CHECKs should only be temporary).

crbug.com/653382 was closed (WontFix) 3 weeks ago, so I think there's nothing
tracking removal of these CHECKs. I don't know if there's another bug for it. If
not, I'd suggest just removing the CHECKs.

[Sam McNally, 2016/11/28 23:33:22]

Ken: thoughts?

[Ken Rockot(use gerrit already), 2016/11/28 23:47:22]

I'd rather just leave the CHECKs in. They aren't needed to track the bug, but
they do serve as a chokepoint for crash reports which are ultimately the result
of manifest resource corruption.

[Sam McNally, 2016/11/29 03:30:14]

Changed to DCHECKs.

+
+    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(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);
+    }
+
     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 84 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