Changes html_viewer to get services from appropriate application

There are actually two changes here:
. Convert HTMLViewerApplication to use an ApplicationImpl rather than
  be an Application.
. Make HTMLDocument use services from the application it was created
  for rather than HTMLViewer's application.

BUG=none
TEST=none
R=jam@chromium.org

Review URL: https://codereview.chromium.org/1165013005

Cr-Commit-Position: refs/heads/master@{#333050}

components/html_viewer/html_document.cc

@@ -142,21 +142,20 @@ bool CanNavigateLocally(blink::WebFrame* frame,
 
 }  // namespace
 
-HTMLDocument::HTMLDocument(
-    mojo::InterfaceRequest<mojo::ServiceProvider> services,
-    URLResponsePtr response,
-    mojo::ShellPtr shell,
-    Setup* setup)
-    : app_refcount_(setup->app()->app_lifetime_helper()->CreateAppRefCount()),
+HTMLDocument::HTMLDocument(mojo::ApplicationImpl* html_document_app,
+                           mojo::ApplicationConnection* connection,
+                           URLResponsePtr response,
+                           Setup* setup)
+    : app_refcount_(
+          html_document_app->app_lifetime_helper()->CreateAppRefCount()),
+      html_document_app_(html_document_app),
       response_(response.Pass()),
-      shell_(shell.Pass()),
       web_view_(nullptr),
       root_(nullptr),
-      view_manager_client_factory_(shell_.get(), this),
+      view_manager_client_factory_(html_document_app->shell(), this),
       setup_(setup) {
-  exported_services_.AddService(this);
-  exported_services_.AddService(&view_manager_client_factory_);
-  exported_services_.Bind(services.Pass());
+  connection->AddService(this);
+  connection->AddService(&view_manager_client_factory_);
   if (setup_->did_init())
     Load(response_.Pass());
 }
@@ -272,13 +271,13 @@ void HTMLDocument::initializeLayerTreeView() {
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From("mojo:surfaces_service");
   mojo::SurfacePtr surface;
-  setup_->app()->ConnectToService(request.Pass(), &surface);
+  html_document_app_->ConnectToService(request.Pass(), &surface);
 
   // TODO(jamesr): Should be mojo:gpu_service
   mojo::URLRequestPtr request2(mojo::URLRequest::New());
   request2->url = mojo::String::From("mojo:view_manager");
   mojo::GpuPtr gpu_service;
-  setup_->app()->ConnectToService(request2.Pass(), &gpu_service);
+  html_document_app_->ConnectToService(request2.Pass(), &gpu_service);
   web_layer_tree_view_impl_.reset(new WebLayerTreeViewImpl(
       setup_->compositor_thread(), surface.Pass(), gpu_service.Pass()));
 }
@@ -292,8 +291,8 @@ blink::WebMediaPlayer* HTMLDocument::createMediaPlayer(
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client,
     blink::WebContentDecryptionModule* initial_cdm) {
-  return setup_->media_factory()->CreateMediaPlayer(frame, url, client,
-                                                    initial_cdm, shell_.get());
+  return setup_->media_factory()->CreateMediaPlayer(
+      frame, url, client, initial_cdm, html_document_app_->shell());
 }
 
 blink::WebFrame* HTMLDocument::createChildFrame(
@@ -409,7 +408,6 @@ void HTMLDocument::OnViewViewportMetricsChanged(
 void HTMLDocument::OnViewDestroyed(View* view) {
   DCHECK_EQ(view, root_);
   root_ = nullptr;
-  shell_->QuitApplication();
 }
 
 void HTMLDocument::OnViewInputEvent(View* view, const mojo::EventPtr& event) {

components/html_viewer/html_document.h

@@ -51,16 +51,12 @@ class HTMLDocument : public blink::WebViewClient,
                      public mojo::InterfaceFactory<mojo::AxProvider> {
  public:
   // Load a new HTMLDocument with |response|.
-  //
-  // |services| should be used to implement a ServiceProvider which exposes
-  // services to the connecting application.
-  // Commonly, the connecting application is the ViewManager and it will
-  // request ViewManagerClient.
-  //
-  // |shell| is the Shell connection for this mojo::Application.
-  HTMLDocument(mojo::InterfaceRequest<mojo::ServiceProvider> services,
+  // |html_document_app| is the application this app was created in, and
+  // |connection| the specific connection triggering this new instance.
+  // |setup| is used to obtain init type state (such as resources).
+  HTMLDocument(mojo::ApplicationImpl* html_document_app,
+               mojo::ApplicationConnection* connection,
                mojo::URLResponsePtr response,
-               mojo::ShellPtr shell,
                Setup* setup);
   ~HTMLDocument() override;
 
@@ -140,10 +136,9 @@ class HTMLDocument : public blink::WebViewClient,
   void ConvertLocalFrameToRemoteFrame(blink::WebLocalFrame* frame);
 
   scoped_ptr<mojo::AppRefCount> app_refcount_;
+  mojo::ApplicationImpl* html_document_app_;
   mojo::URLResponsePtr response_;
-  mojo::ServiceProviderImpl exported_services_;
   mojo::ServiceProviderPtr embedder_service_provider_;
-  mojo::ShellPtr shell_;
   mojo::LazyInterfacePtr<mojo::NavigatorHost> navigator_host_;
   blink::WebView* web_view_;
   mojo::View* root_;

components/html_viewer/html_viewer.cc

@@ -40,35 +40,44 @@ namespace html_viewer {
 
 class HTMLViewer;
 
-class HTMLViewerApplication : public mojo::Application {
+// ApplicationDelegate created by the content handler for a specific url.
+class HTMLDocumentApplicationDelegate : public mojo::ApplicationDelegate {
  public:
-  HTMLViewerApplication(InterfaceRequest<Application> request,
-                        URLResponsePtr response,
-                        Setup* setup)
-      : app_refcount_(setup->app()->app_lifetime_helper()->CreateAppRefCount()),
+  HTMLDocumentApplicationDelegate(
+      mojo::InterfaceRequest<mojo::Application> request,
+      mojo::URLResponsePtr response,
+      Setup* setup,
+      scoped_ptr<mojo::AppRefCount> parent_app_refcount)
+      : app_(this,
+             request.Pass(),
+             base::Bind(&HTMLDocumentApplicationDelegate::OnTerminate,
+                        base::Unretained(this))),
+        parent_app_refcount_(parent_app_refcount.Pass()),
         url_(response->url),
-        binding_(this, request.Pass()),
         initial_response_(response.Pass()),
-        setup_(setup) {
-  }
+        setup_(setup) {}
+
+ private:
+  ~HTMLDocumentApplicationDelegate() override {}
 
-  ~HTMLViewerApplication() override {
+  // Callback from the quit closure. We key off this rather than
+  // ApplicationDelegate::Quit() as we don't want to shut down the messageloop
+  // when we quit (the messageloop is shared among multiple
+  // HTMLDocumentApplicationDelegates).
+  void OnTerminate() {
+    delete this;
   }
 
-  void Initialize(ShellPtr shell, const String& url) override {
-    shell_ = shell.Pass();
+  // ApplicationDelegate;
+  void Initialize(mojo::ApplicationImpl* app) override {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From("mojo:network_service");
-    setup_->app()->ConnectToService(request.Pass(), &network_service_);
+    app_.ConnectToService(request.Pass(), (&network_service_));
   }
-
-  void AcceptConnection(const String& requestor_url,
-                        InterfaceRequest<ServiceProvider> services,
-                        ServiceProviderPtr exposed_services,
-                        const String& url) override {
+  bool ConfigureIncomingConnection(
+      mojo::ApplicationConnection* connection) override {
     if (initial_response_) {
-      OnResponseReceived(URLLoaderPtr(), services.Pass(),
-                         initial_response_.Pass());
+      OnResponseReceived(URLLoaderPtr(), connection, initial_response_.Pass());
     } else {
       URLLoaderPtr loader;
       network_service_->CreateURLLoader(GetProxy(&loader));
@@ -76,60 +85,59 @@ class HTMLViewerApplication : public mojo::Application {
       request->url = url_;
       request->auto_follow_redirects = true;
 
-      // |loader| will be pass to the OnResponseReceived method through a
+      // |loader| will be passed to the OnResponseReceived method through a
       // callback. Because order of evaluation is undefined, a reference to the
       // raw pointer is needed.
       mojo::URLLoader* raw_loader = loader.get();
       raw_loader->Start(
           request.Pass(),
-          base::Bind(&HTMLViewerApplication::OnResponseReceived,
+          base::Bind(&HTMLDocumentApplicationDelegate::OnResponseReceived,
                      base::Unretained(this), base::Passed(&loader),
-                     base::Passed(&services)));
+                     connection));
     }
+    return true;
   }
 
-  void OnQuitRequested(const mojo::Callback<void(bool)>& callback) override {
-    callback.Run(true);
-    delete this;
-  }
-
- private:
   void OnResponseReceived(URLLoaderPtr loader,
-                          InterfaceRequest<ServiceProvider> services,
+                          mojo::ApplicationConnection* connection,
                           URLResponsePtr response) {
     // HTMLDocument is destroyed when the hosting view is destroyed.
     // TODO(sky): when headless, this leaks.
-    new HTMLDocument(services.Pass(), response.Pass(), shell_.Pass(), setup_);
+    // TODO(sky): this needs to delete if serviceprovider goes away too.
+    new HTMLDocument(&app_, connection, response.Pass(), setup_);
   }
 
-  scoped_ptr<mojo::AppRefCount> app_refcount_;
-  String url_;
-  mojo::StrongBinding<mojo::Application> binding_;
-  ShellPtr shell_;
+  mojo::ApplicationImpl app_;
+  // AppRefCount of the parent (HTMLViewer).
+  scoped_ptr<mojo::AppRefCount> parent_app_refcount_;
+  const String url_;
   mojo::NetworkServicePtr network_service_;
   URLResponsePtr initial_response_;
   Setup* setup_;
 
-  DISALLOW_COPY_AND_ASSIGN(HTMLViewerApplication);
+  DISALLOW_COPY_AND_ASSIGN(HTMLDocumentApplicationDelegate);
 };
 
 class ContentHandlerImpl : public mojo::ContentHandler {
  public:
   ContentHandlerImpl(Setup* setup,
+                     mojo::ApplicationImpl* app,
                      mojo::InterfaceRequest<ContentHandler> request)
-      : setup_(setup),
-        binding_(this, request.Pass()) {}
+      : setup_(setup), app_(app), binding_(this, request.Pass()) {}
   ~ContentHandlerImpl() override {}
 
  private:
   // Overridden from ContentHandler:
   void StartApplication(InterfaceRequest<mojo::Application> request,
                         URLResponsePtr response) override {
-    // HTMLViewerApplication is owned by the binding.
-    new HTMLViewerApplication(request.Pass(), response.Pass(), setup_);
+    // HTMLDocumentApplicationDelegate deletes itself.
+    new HTMLDocumentApplicationDelegate(
+        request.Pass(), response.Pass(), setup_,
+        app_->app_lifetime_helper()->CreateAppRefCount());
   }
 
   Setup* setup_;
+  mojo::ApplicationImpl* app_;
   mojo::StrongBinding<mojo::ContentHandler> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl);
@@ -138,12 +146,13 @@ class ContentHandlerImpl : public mojo::ContentHandler {
 class HTMLViewer : public mojo::ApplicationDelegate,
                    public mojo::InterfaceFactory<ContentHandler> {
  public:
-  HTMLViewer() {}
+  HTMLViewer() : app_(nullptr) {}
   ~HTMLViewer() override {}
 
  private:
   // Overridden from ApplicationDelegate:
   void Initialize(mojo::ApplicationImpl* app) override {
+    app_ = app;
     setup_.reset(new Setup(app));
   }
 
@@ -162,10 +171,11 @@ class HTMLViewer : public mojo::ApplicationDelegate,
   // Overridden from InterfaceFactory<ContentHandler>
   void Create(ApplicationConnection* connection,
               mojo::InterfaceRequest<ContentHandler> request) override {
-    new ContentHandlerImpl(setup_.get(), request.Pass());
+    new ContentHandlerImpl(setup_.get(), app_, request.Pass());
   }
 
   scoped_ptr<Setup> setup_;
+  mojo::ApplicationImpl* app_;
 
   DISALLOW_COPY_AND_ASSIGN(HTMLViewer);
 };

components/html_viewer/setup.h

@@ -49,7 +49,6 @@ class Setup {
   void InitIfNecessary(const gfx::Size& screen_size_in_pixels,
                        float device_pixel_ratio);
 
-  mojo::ApplicationImpl* app() const { return app_; }
   bool is_headless() const { return is_headless_; }
   bool did_init() const { return did_init_; }
 
@@ -66,6 +65,9 @@ class Setup {
   MediaFactory* media_factory() { return media_factory_.get(); }
 
  private:
+  // App for HTMLViewer, not the document's app.
+  // WARNING: do not expose this. It's too easy to use the wrong one.
+  // HTMLDocument should be using the application it creates, not this one.
   mojo::ApplicationImpl* app_;
 
   resource_provider::ResourceLoader resource_loader_;

mojo/application/public/cpp/application_impl.h

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/memory/weak_ptr.h"
 #include "mojo/application/public/cpp/app_lifetime_helper.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_delegate.h"
@@ -133,6 +134,7 @@ class ApplicationImpl : public Application,
   base::Closure termination_closure_;
   AppLifetimeHelper app_lifetime_helper_;
   bool quit_requested_;
+  base::WeakPtrFactory<ApplicationImpl> weak_factory_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ApplicationImpl);
 };

mojo/application/public/cpp/lib/application_impl.cc

@@ -35,7 +35,8 @@ ApplicationImpl::ApplicationImpl(ApplicationDelegate* delegate,
       binding_(this, request.Pass()),
       termination_closure_(termination_closure),
       app_lifetime_helper_(this),
-      quit_requested_(false) {
+      quit_requested_(false),
+      weak_factory_(this) {
 }
 
 void ApplicationImpl::ClearConnections() {
@@ -140,7 +141,10 @@ void ApplicationImpl::OnQuitRequested(const Callback<void(bool)>& callback) {
 }
 
 void ApplicationImpl::OnConnectionError() {
+  base::WeakPtr<ApplicationImpl> ptr(weak_factory_.GetWeakPtr());
   QuitNow();
+  if (!ptr)
+    return;
   shell_ = nullptr;
 }