Rename ApplicationDelegate to ShellClient

components/pdf_viewer/pdf_viewer.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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/bitmap_uploader/bitmap_uploader.h"
 #include "components/mus/common/types.h"
 #include "components/mus/public/cpp/input_event_handler.h"
 #include "components/mus/public/cpp/scoped_window_ptr.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
 #include "components/mus/public/cpp/window_tree_delegate.h"
 #include "components/mus/public/interfaces/input_events.mojom.h"
 #include "components/mus/public/interfaces/input_key_codes.mojom.h"
 #include "components/web_view/public/interfaces/frame.mojom.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/services/tracing/public/cpp/tracing_impl.h"
-#include "mojo/shell/public/cpp/application_connection.h"
-#include "mojo/shell/public/cpp/application_delegate.h"
 #include "mojo/shell/public/cpp/application_impl.h"
 #include "mojo/shell/public/cpp/application_runner.h"
-#include "mojo/shell/public/cpp/connect.h"
 #include "mojo/shell/public/cpp/interface_factory_impl.h"
-#include "mojo/shell/public/cpp/service_provider_impl.h"
+#include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/interfaces/content_handler.mojom.h"
 #include "mojo/shell/public/interfaces/shell.mojom.h"
 #include "third_party/pdfium/public/fpdf_ext.h"
 #include "third_party/pdfium/public/fpdfview.h"
 #include "ui/gfx/geometry/rect.h"
 #include "v8/include/v8.h"
 
 const uint32_t g_background_color = 0xFF888888;
 
 namespace pdf_viewer {
 namespace {
 
 // Responsible for managing a particlar view displaying a PDF document.
 class PDFView : public mus::WindowTreeDelegate,
                 public mus::WindowObserver,
                 public mus::InputEventHandler,
                 public web_view::mojom::FrameClient,
                 public mojo::InterfaceFactory<web_view::mojom::FrameClient> {
  public:
   using DeleteCallback = base::Callback<void(PDFView*)>;
 
   PDFView(mojo::Shell* shell,
-          mojo::ApplicationConnection* connection,
+          mojo::Connection* connection,
           FPDF_DOCUMENT doc,
           const DeleteCallback& delete_callback)
       : app_ref_(shell->CreateAppRefCount()),
         doc_(doc),
         current_page_(0),
         page_count_(FPDF_GetPageCount(doc_)),
         shell_(shell),
         root_(nullptr),
         frame_client_binding_(this),
         delete_callback_(delete_callback) {
@@ skipping 140 matching lines @@
   void HighlightFindResults(int32_t request_id,
                             const mojo::String& search_test,
                             web_view::mojom::FindOptionsPtr options,
                             bool reset) override {
     NOTIMPLEMENTED();
   }
   void StopHighlightingFindResults() override {}
 
   // mojo::InterfaceFactory<web_view::mojom::FrameClient>:
   void Create(
-      mojo::ApplicationConnection* connection,
+      mojo::Connection* connection,
       mojo::InterfaceRequest<web_view::mojom::FrameClient> request) override {
     frame_client_binding_.Bind(std::move(request));
   }
 
   scoped_ptr<mojo::AppRefCount> app_ref_;
   FPDF_DOCUMENT doc_;
   int current_page_;
   int page_count_;
 
   scoped_ptr<bitmap_uploader::BitmapUploader> bitmap_uploader_;
 
   mojo::Shell* shell_;
   mus::Window* root_;
 
   web_view::mojom::FramePtr frame_;
   mojo::Binding<web_view::mojom::FrameClient> frame_client_binding_;
   DeleteCallback delete_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PDFView);
 };
 
 // Responsible for managing all the views for displaying a PDF document.
 class PDFViewerApplicationDelegate
-    : public mojo::ApplicationDelegate,
+    : public mojo::ShellClient,
       public mojo::InterfaceFactory<mus::mojom::WindowTreeClient> {
  public:
   PDFViewerApplicationDelegate(
       mojo::ApplicationRequest request,
       mojo::URLResponsePtr response,
       const mojo::Callback<void()>& destruct_callback)
       : app_(this,
              std::move(request),
              base::Bind(&PDFViewerApplicationDelegate::OnTerminate,
                         base::Unretained(this))),
@@ skipping 16 matching lines @@
   void FetchPDF(mojo::URLResponsePtr response) {
     data_.clear();
     mojo::common::BlockingCopyToString(std::move(response->body), &data_);
     if (data_.length() >= static_cast<size_t>(std::numeric_limits<int>::max()))
       return;
     doc_ = FPDF_LoadMemDocument(data_.data(), static_cast<int>(data_.length()),
                                 nullptr);
   }
 
   // Callback from the quit closure. We key off this rather than
-  // ApplicationDelegate::Quit() as we don't want to shut down the messageloop
+  // ShellClient::Quit() as we don't want to shut down the messageloop
   // when we quit (the messageloop is shared among multiple PDFViews).
   void OnTerminate() { delete this; }
 
   void OnPDFViewDestroyed(PDFView* pdf_view) {
     DCHECK(std::find(pdf_views_.begin(), pdf_views_.end(), pdf_view) !=
            pdf_views_.end());
     pdf_views_.erase(std::find(pdf_views_.begin(), pdf_views_.end(), pdf_view));
   }
 
-  // ApplicationDelegate:
-  bool AcceptConnection(
-      mojo::ApplicationConnection* connection) override {
+  // mojo::ShellClient:
+  bool AcceptConnection(mojo::Connection* connection) override {
     connection->AddService<mus::mojom::WindowTreeClient>(this);
     return true;
   }
 
   // mojo::InterfaceFactory<mus::mojom::WindowTreeClient>:
   void Create(
-      mojo::ApplicationConnection* connection,
+      mojo::Connection* connection,
       mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request) override {
     PDFView* pdf_view = new PDFView(
         &app_, connection, doc_,
         base::Bind(&PDFViewerApplicationDelegate::OnPDFViewDestroyed,
                    base::Unretained(this)));
     pdf_views_.push_back(pdf_view);
     mus::WindowTreeConnection::Create(
         pdf_view, std::move(request),
         mus::WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
   }
@@ skipping 24 matching lines @@
     new PDFViewerApplicationDelegate(std::move(request), std::move(response),
                                      destruct_callback);
   }
 
   mojo::StrongBinding<mojo::shell::mojom::ContentHandler> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl);
 };
 
 class PDFViewer
-    : public mojo::ApplicationDelegate,
+    : public mojo::ShellClient,
       public mojo::InterfaceFactory<mojo::shell::mojom::ContentHandler> {
  public:
   PDFViewer() {
     v8::V8::InitializeICU();
     FPDF_InitLibrary();
   }
 
   ~PDFViewer() override { FPDF_DestroyLibrary(); }
 
  private:
-  // ApplicationDelegate:
+  // mojo::ShellClient:
   void Initialize(mojo::Shell* shell, const std::string& url,
                   uint32_t id) override {
     tracing_.Initialize(shell, url);
   }
 
-  bool AcceptConnection(
-      mojo::ApplicationConnection* connection) override {
+  bool AcceptConnection(mojo::Connection* connection) override {
     connection->AddService(this);
     return true;
   }
 
   // InterfaceFactory<ContentHandler>:
-  void Create(mojo::ApplicationConnection* connection,
+  void Create(mojo::Connection* connection,
               mojo::InterfaceRequest<mojo::shell::mojom::ContentHandler>
                   request) override {
     new ContentHandlerImpl(std::move(request));
   }
 
   mojo::TracingImpl tracing_;
 
   DISALLOW_COPY_AND_ASSIGN(PDFViewer);
 };
 }  // namespace
 }  // namespace pdf_viewer
 
 MojoResult MojoMain(MojoHandle application_request) {
   mojo::ApplicationRunner runner(new pdf_viewer::PDFViewer());
   return runner.Run(application_request);
 }