Rename ApplicationDelegate to ShellClient

mojo/shell/capability_filter_test.h

 // 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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/application_manager.h"
 #include "mojo/shell/capability_filter_unittest.mojom.h"
-#include "mojo/shell/public/cpp/application_delegate.h"
+#include "mojo/shell/public/cpp/application_impl.h"
+#include "mojo/shell/public/cpp/shell_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace test {
 
 class ConnectionValidator;
 
 // This class models an application who will use the shell to interact with a
 // system service. The shell may limit this application's visibility of the full
 // set of interfaces exposed by that service.
-class TestApplication : public ApplicationDelegate {
+class TestApplication : public ShellClient {
  public:
   TestApplication();
   ~TestApplication() override;
 
  private:
-  // Overridden from ApplicationDelegate:
+  // Overridden from ShellClient:
   void Initialize(Shell* shell, const std::string& url, uint32_t id) override;
-  bool AcceptConnection(ApplicationConnection* connection) override;
+  bool AcceptConnection(Connection* connection) override;
 
   void ConnectionClosed(const std::string& service_url);
 
   Shell* shell_;
   std::string url_;
   ValidatorPtr validator_;
-  scoped_ptr<ApplicationConnection> connection1_;
-  scoped_ptr<ApplicationConnection> connection2_;
+  scoped_ptr<Connection> connection1_;
+  scoped_ptr<Connection> connection2_;
 
   DISALLOW_COPY_AND_ASSIGN(TestApplication);
 };
 
 class TestLoader : public ApplicationLoader {
  public:
-  explicit TestLoader(ApplicationDelegate* delegate);
+  explicit TestLoader(ShellClient* delegate);
   ~TestLoader() override;
 
  private:
   // Overridden from ApplicationLoader:
   void Load(const GURL& url,
             InterfaceRequest<mojom::Application> request) override;
 
-  scoped_ptr<ApplicationDelegate> delegate_;
+  scoped_ptr<ShellClient> delegate_;
   scoped_ptr<ApplicationImpl> app_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLoader);
 };
 
 class CapabilityFilterTest : public testing::Test {
  public:
    CapabilityFilterTest();
    ~CapabilityFilterTest() override;
 
@@ skipping 20 matching lines @@
     return application_manager_.get();
   }
   ConnectionValidator* validator() { return validator_; }
 
  private:
   void RunApplication(const std::string& url, const CapabilityFilter& filter);
   void InitValidator(const std::set<std::string>& expectations);
   void RunTest();
 
   template<class T>
-  scoped_ptr<ApplicationDelegate> CreateApplicationDelegate() {
-    return scoped_ptr<ApplicationDelegate>(new T);
+  scoped_ptr<ShellClient> CreateShellClient() {
+    return scoped_ptr<ShellClient>(new T);
   }
 
   base::ShadowingAtExitManager at_exit_;
   base::MessageLoop loop_;
   scoped_ptr<ApplicationManager> application_manager_;
   ConnectionValidator* validator_;
 
   DISALLOW_COPY_AND_ASSIGN(CapabilityFilterTest);
 };
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo