Rename ApplicationDelegate to ShellClient

components/html_viewer/html_document_application_delegate.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 "components/html_viewer/html_document_application_delegate.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "components/html_viewer/global_state.h"
 #include "components/html_viewer/html_document.h"
-#include "mojo/shell/public/cpp/application_connection.h"
-#include "mojo/shell/public/cpp/application_delegate.h"
-#include "mojo/shell/public/cpp/connect.h"
+#include "mojo/shell/public/cpp/shell_client.h"
 
 namespace html_viewer {
 
 // ServiceConnectorQueue records all incoming service requests and processes
 // them once PushRequestsTo() is called. This is useful if you need to delay
 // processing incoming service requests.
 class HTMLDocumentApplicationDelegate::ServiceConnectorQueue
     : public mojo::ServiceConnector {
  public:
   ServiceConnectorQueue() {}
   ~ServiceConnectorQueue() override {}
 
-  void PushRequestsTo(mojo::ApplicationConnection* connection) {
+  void PushRequestsTo(mojo::Connection* connection) {
     ScopedVector<Request> requests;
     requests_.swap(requests);
     for (Request* request : requests) {
       connection->GetLocalServiceProvider()->ConnectToService(
           request->interface_name, std::move(request->handle));
     }
   }
 
  private:
   struct Request {
     std::string interface_name;
     mojo::ScopedMessagePipeHandle handle;
   };
 
   // mojo::ServiceConnector:
-  void ConnectToService(mojo::ApplicationConnection* application_connection,
+  void ConnectToService(mojo::Connection* connection,
                         const std::string& interface_name,
                         mojo::ScopedMessagePipeHandle handle) override {
     scoped_ptr<Request> request(new Request);
     request->interface_name = interface_name;
     request->handle = std::move(handle);
     requests_.push_back(std::move(request));
   }
 
   ScopedVector<Request> requests_;
 
@@ skipping 23 matching lines @@
   // OnHTMLDocumentDeleted() and remove from |documents_|. Copy the set so we
   // don't have to worry about the set being modified out from under us.
   std::set<HTMLDocument*> documents2(documents2_);
   for (HTMLDocument* doc : documents2)
     doc->Destroy();
   DCHECK(documents2_.empty());
   destruct_callback_.Run();
 }
 
 // Callback from the quit closure. We key off this rather than
-// ApplicationDelegate::Quit() as we don't want to shut down the messageloop
+// mojo::ShellClient::Quit() as we don't want to shut down the messageloop
 // when we quit (the messageloop is shared among multiple
 // HTMLDocumentApplicationDelegates).
 void HTMLDocumentApplicationDelegate::OnTerminate() {
   delete this;
 }
 
-// ApplicationDelegate;
+// mojo::ShellClient;
 void HTMLDocumentApplicationDelegate::Initialize(mojo::Shell* shell,
                                                  const std::string& url,
                                                  uint32_t id) {
   app_.ConnectToService("mojo:network_service", &url_loader_factory_);
 }
 
 bool HTMLDocumentApplicationDelegate::AcceptConnection(
-    mojo::ApplicationConnection* connection) {
+    mojo::Connection* connection) {
   if (initial_response_) {
     OnResponseReceived(nullptr, mojo::URLLoaderPtr(), connection, nullptr,
                        std::move(initial_response_));
   } else if (url_ == "about:blank") {
     // This is a little unfortunate. At the browser side, when starting a new
     // app for "about:blank", the application manager uses
     // mojo::shell::AboutFetcher to construct a response for "about:blank".
     // However, when an app for "about:blank" already exists, it is reused and
     // we end up here. We cannot fetch the URL using mojo::URLLoader because it
     // is not an actual Web resource.
@@ skipping 36 matching lines @@
 
 void HTMLDocumentApplicationDelegate::OnHTMLDocumentDeleted2(
     HTMLDocument* document) {
   DCHECK(documents2_.count(document) > 0);
   documents2_.erase(document);
 }
 
 void HTMLDocumentApplicationDelegate::OnResponseReceived(
     scoped_ptr<mojo::AppRefCount> app_refcount,
     mojo::URLLoaderPtr loader,
-    mojo::ApplicationConnection* connection,
+    mojo::Connection* connection,
     scoped_ptr<ServiceConnectorQueue> connector_queue,
     mojo::URLResponsePtr response) {
   // HTMLDocument is destroyed when the hosting view is destroyed, or
   // explicitly from our destructor.
   HTMLDocument* document = new HTMLDocument(
       &app_, connection, std::move(response), global_state_,
       base::Bind(&HTMLDocumentApplicationDelegate::OnHTMLDocumentDeleted2,
                  base::Unretained(this)),
       html_factory_);
   documents2_.insert(document);
 
   if (connector_queue) {
     connector_queue->PushRequestsTo(connection);
     connection->SetServiceConnector(nullptr);
   }
 }
 
 HTMLFrame* HTMLDocumentApplicationDelegate::CreateHTMLFrame(
     HTMLFrame::CreateParams* params) {
   return new HTMLFrame(params);
 }
 
 HTMLWidgetRootLocal* HTMLDocumentApplicationDelegate::CreateHTMLWidgetRootLocal(
     HTMLWidgetRootLocal::CreateParams* params) {
   return new HTMLWidgetRootLocal(params);
 }
 
 }  // namespace html_viewer