Allow trusted brokers to restrict connections for spawned applications to whitelisted applications …

content/browser/mojo/mojo_shell_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/mojo/mojo_shell_context.h"
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 80 matching lines @@
   Proxy(MojoShellContext* shell_context)
       : shell_context_(shell_context),
         task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   ~Proxy() {}
 
   void ConnectToApplication(
       const GURL& url,
       const GURL& requestor_url,
       mojo::InterfaceRequest<mojo::ServiceProvider> request,
-      mojo::ServiceProviderPtr exposed_services) {
+      mojo::ServiceProviderPtr exposed_services,
+      mojo::CapabilityFilterPtr filter) {
     if (task_runner_ == base::ThreadTaskRunnerHandle::Get()) {
       if (shell_context_) {
         shell_context_->ConnectToApplicationOnOwnThread(
-            url, requestor_url, request.Pass(), exposed_services.Pass());
+            url, requestor_url, request.Pass(), exposed_services.Pass(),
+            filter.Pass());
       }
     } else {
       // |shell_context_| outlives the main MessageLoop, so it's safe for it to
       // be unretained here.
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&MojoShellContext::ConnectToApplicationOnOwnThread,
                      base::Unretained(shell_context_), url, requestor_url,
-                     base::Passed(&request), base::Passed(&exposed_services)));
+                     base::Passed(&request), base::Passed(&exposed_services),
+                     base::Passed(&filter)));
     }
   }
 
  private:
   MojoShellContext* shell_context_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Proxy);
 };
 
@@ skipping 50 matching lines @@
 }
 
 MojoShellContext::~MojoShellContext() {
 }
 
 // static
 void MojoShellContext::ConnectToApplication(
     const GURL& url,
     const GURL& requestor_url,
     mojo::InterfaceRequest<mojo::ServiceProvider> request,
-    mojo::ServiceProviderPtr exposed_services) {
+    mojo::ServiceProviderPtr exposed_services,
+    mojo::CapabilityFilterPtr filter) {
   proxy_.Get()->ConnectToApplication(url, requestor_url, request.Pass(),
-                                     exposed_services.Pass());
+                                     exposed_services.Pass(), filter.Pass());
 }
 
 void MojoShellContext::ConnectToApplicationOnOwnThread(
     const GURL& url,
     const GURL& requestor_url,
     mojo::InterfaceRequest<mojo::ServiceProvider> request,
-    mojo::ServiceProviderPtr exposed_services) {
+    mojo::ServiceProviderPtr exposed_services,
+    mojo::CapabilityFilterPtr filter) {
   mojo::URLRequestPtr url_request = mojo::URLRequest::New();
   url_request->url = mojo::String::From(url);
   application_manager_->ConnectToApplication(
-      url_request.Pass(), std::string(), requestor_url, request.Pass(),
-      exposed_services.Pass(), base::Bind(&base::DoNothing));
+      nullptr, url_request.Pass(), std::string(), requestor_url, request.Pass(),
+      exposed_services.Pass(), filter.Pass(), base::Bind(&base::DoNothing));
 }
 
 GURL MojoShellContext::ResolveMappings(const GURL& url) {
   return url;
 }
 
 GURL MojoShellContext::ResolveMojoURL(const GURL& url) {
   return url;
 }
 
 bool MojoShellContext::CreateFetcher(
     const GURL& url,
     const mojo::shell::Fetcher::FetchCallback& loader_callback) {
   return false;
 }
 
 }  // namespace content