Capability Classes

mojo/shell/tests/connect/connect_test_app.cc

 // Copyright 2016 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 "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/shell/public/cpp/application_runner.h"
 #include "mojo/shell/public/cpp/connector.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/interfaces/connector.mojom.h"
 #include "mojo/shell/tests/connect/connect_test.mojom.h"
 
 namespace mojo {
 namespace shell {
+namespace {
+void ReceiveString(std::string* string, base::RunLoop* loop,
+                   const std::string& response) {
+  *string = response;
+  loop->Quit();
+}
+}
 
 using GetTitleCallback = test::mojom::ConnectTestService::GetTitleCallback;
 
 class ConnectTestApp : public ShellClient,
                        public InterfaceFactory<test::mojom::ConnectTestService>,
                        public InterfaceFactory<test::mojom::StandaloneApp>,
                        public InterfaceFactory<test::mojom::BlockedInterface>,
                        public test::mojom::ConnectTestService,
                        public test::mojom::StandaloneApp,
                        public test::mojom::BlockedInterface {
@@ skipping 82 matching lines @@
         base::Bind(&ConnectTestApp::OnGotTitle, base::Unretained(this),
                    callback, &run_loop));
     {
       // This message is dispatched as a task on the same run loop, so we need
       // to allow nesting in order to pump additional signals.
       base::MessageLoop::ScopedNestableTaskAllower allow(
           base::MessageLoop::current());
       run_loop.Run();
     }
   }
+  void ConnectToClassInterface(
+      const ConnectToClassInterfaceCallback& callback) override {
+    scoped_ptr<Connection> connection =
+        connector_->Connect("mojo:connect_test_class_app");
+    test::mojom::ClassInterfacePtr class_interface;
+    connection->GetInterface(&class_interface);
+    std::string ping_response;
+    {
+      base::RunLoop loop;
+      class_interface->Ping(base::Bind(&ReceiveString, &ping_response, &loop));
+      base::MessageLoop::ScopedNestableTaskAllower allow(
+          base::MessageLoop::current());
+      loop.Run();
+    }
+    test::mojom::ConnectTestServicePtr service;
+    connection->GetInterface(&service);
+    std::string title_response;
+    {
+      base::RunLoop loop;
+      service->GetTitle(base::Bind(&ReceiveString, &title_response, &loop));
+      base::MessageLoop::ScopedNestableTaskAllower allow(
+          base::MessageLoop::current());
+      loop.Run();
+    }
+    callback.Run(ping_response, title_response);
+  }
 
   // test::mojom::BlockedInterface:
   void GetTitleBlocked(const GetTitleBlockedCallback& callback) override {
     callback.Run("Called Blocked Interface!");
   }
 
   void OnConnectionBlocked(
       const ConnectToAllowedAppInBlockedPackageCallback& callback,
       base::RunLoop* run_loop) {
     callback.Run("uninitialized");
@@ skipping 26 matching lines @@
 
 }  // namespace shell
 }  // namespace mojo
 
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   MojoResult rv = mojo::ApplicationRunner(
       new mojo::shell::ConnectTestApp).Run(shell_handle);
   return rv;
 }