Provide capability classes from Mus

services/shell/shell.cc

 // Copyright 2014 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 "services/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 16 matching lines @@
 #include "services/shell/public/interfaces/connector.mojom.h"
 #include "services/shell/public/interfaces/shell.mojom.h"
 #include "services/shell/public/interfaces/shell_client.mojom.h"
 
 namespace shell {
 
 namespace {
 
 const char kCatalogName[] = "mojo:catalog";
 const char kShellName[] = "mojo:shell";
-const char kCapabilityClass_UserID[] = "user_id";
-const char kCapabilityClass_ClientProcess[] = "client_process";
-const char kCapabilityClass_InstanceName[] = "instance_name";
-const char kCapabilityClass_AllUsers[] = "all_users";
+const char kCapabilityClass_UserID[] = "shell:user_id";
+const char kCapabilityClass_ClientProcess[] = "shell:client_process";
+const char kCapabilityClass_InstanceName[] = "shell:instance_name";
+const char kCapabilityClass_AllUsers[] = "shell:all_users";
+const char kCapabilityClass_ExplicitClass[] = "shell:explicit_class";
 
 void EmptyResolverCallback(mojom::ResolveResultPtr result) {}
 
 }  // namespace
 
 Identity CreateShellIdentity() {
   return Identity(kShellName, mojom::kRootUserID);
 }
 
 Identity CreateCatalogIdentity() {
@@ skipping 92 matching lines @@
     DCHECK(it != children_.end());
     children_.erase(it);
     child->parent_ = nullptr;
   }
 
   void ConnectToClient(std::unique_ptr<ConnectParams> params) {
     CHECK(shell_client_.is_bound());
     params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                    identity_.user_id(), id_);
     uint32_t source_id = mojom::kInvalidInstanceID;
-    CapabilityRequest spec;
-    spec.interfaces.insert("*");
+    CapabilityRequest request;
+    request.interfaces.insert("*");
     Instance* source = shell_->GetExistingInstance(params->source());
     if (source) {
-      spec = GenerateCapabilityRequestForConnection(
+      request = GenerateCapabilityRequestForConnection(
           source->capability_spec_, identity_, capability_spec_);
       source_id = source->id();
     }
+
+    // The target has specified that sources must request one of its provided
+    // classes instead of specifying a wild-card for interfaces or interfaces
+    // directly.
+    if (HasClass(capability_spec_, kCapabilityClass_ExplicitClass) &&
+        (request.classes.empty() || request.interfaces.count("*") != 0)) {
+      request.interfaces = Interfaces();
+    }
+
     shell_client_->AcceptConnection(
         mojom::Identity::From(params->source()), source_id,
         params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
-        mojom::CapabilityRequest::From(spec), params->target().name());
+        mojom::CapabilityRequest::From(request), params->target().name());
   }
 
   void StartWithClient(mojom::ShellClientPtr client) {
     CHECK(!shell_client_);
     shell_client_ = std::move(client);
     shell_client_.set_connection_error_handler(
         base::Bind(&Instance::OnShellClientLost, base::Unretained(this),
                    shell_->GetWeakPtr()));
     shell_client_->Initialize(mojom::Identity::From(identity_), id_,
                               base::Bind(&Instance::OnInitializeResponse,
@@ skipping 576 matching lines @@
 void Shell::CleanupRunner(NativeRunner* runner) {
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell