Load application manifests from resources

content/browser/mojo/mojo_child_connection.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/mojo/mojo_child_connection.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/common/mojo_shell_connection.h"
 #include "ipc/ipc_sender.h"
 #include "mojo/converters/network/network_type_converters.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/shell/public/cpp/connector.h"
 #include "mojo/shell/public/interfaces/shell.mojom.h"
 #include "mojo/shell/public/interfaces/shell_client.mojom.h"
@@ skipping 69 matching lines @@
   std::string pipe_token = mojo::edk::GenerateRandomToken();
   mojo::ScopedMessagePipeHandle shell_client_pipe =
       mojo::edk::CreateParentMessagePipe(pipe_token);
 
   // Some process types get created before the main message loop. In this case
   // the shell request pipe will simply be closed, and the child can detect
   // this.
   if (!MojoShellConnection::Get())
     return pipe_token;
 
+  std::string child_name =
+      GetContentClient()->browser()->GetMojoApplicationNameForProcess(
+          PROCESS_TYPE_RENDERER);
+  if (child_name.empty())
+    return pipe_token;

[Ben Goodger (Google), 2016/03/30 22:27:50]

what happens in this case? how does the caller react?

[Ken Rockot(use gerrit already), 2016/03/31 18:55:48]

The caller doesn't know about any failures here, it just passes the token along
to the child. When the child establishes its end of the pipe it'll detect peer
closure since the parent end will have been closed.

This means a little unnecessary work happens in the failure cases, but it also
means less error handling code. We could make this return the empty string
instead. It would probably be easier for readers to understand.

+
   mojo::shell::mojom::ShellClientPtr client;
   client.Bind(mojo::InterfacePtrInfo<mojo::shell::mojom::ShellClient>(
       std::move(shell_client_pipe), 0u));
   mojo::shell::mojom::PIDReceiverPtr pid_receiver;
   mojo::shell::mojom::PIDReceiverRequest pid_receiver_request =
       GetProxy(&pid_receiver);
   // PIDSender manages its own lifetime.
   new PIDSender(render_process_host, std::move(pid_receiver));
 
-
-  mojo::Identity target("exe:chrome_renderer",
-                        mojo::shell::mojom::kInheritUserID,
+  mojo::Identity target(child_name, mojo::shell::mojom::kInheritUserID,
                         base::StringPrintf("%d_%d", child_process_id,
                                            instance_id));
   mojo::Connector::ConnectParams params(target);
   params.set_client_process_connection(std::move(client),
                                        std::move(pid_receiver_request));
   scoped_ptr<mojo::Connection> connection =
       MojoShellConnection::Get()->GetConnector()->Connect(&params);
 
   // Store the connection on the RPH so client code can access it later via
   // GetMojoConnection().
   SetMojoConnection(render_process_host, std::move(connection));
 
   return pipe_token;
 }
 
 mojo::Connection* GetMojoConnection(RenderProcessHost* render_process_host) {
   RenderProcessHostConnection* connection =
       static_cast<RenderProcessHostConnection*>(
           render_process_host->GetUserData(kMojoRenderProcessHostConnection));
   return connection ? connection->get() : nullptr;
 }
 
 }  // namespace content