Add some simple HTMLViewer apptests.

mojo/services/html_viewer/html_viewer.cc

 // Copyright 2014 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/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "gin/public/isolate_holder.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/services/html_viewer/discardable_memory_allocator.h"
 #include "mojo/services/html_viewer/html_document.h"
 #include "mojo/services/html_viewer/mojo_blink_platform_impl.h"
+#include "mojo/services/html_viewer/public/interfaces/html_viewer.mojom.h"
 #include "mojo/services/html_viewer/webmediaplayer_factory.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/mojo/src/mojo/public/c/system/main.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_connection.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_delegate.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_impl.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/connect.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/interface_factory_impl.h"
@@ skipping 31 matching lines @@
 // Disables support for (unprefixed) Encrypted Media Extensions.
 const char kDisableEncryptedMedia[] = "disable-encrypted-media";
 
 // Prevents creation of any output surface.
 const char kIsHeadless[] = "is-headless";
 
 size_t kDesiredMaxMemory = 20 * 1024 * 1024;
 
 class HTMLViewer;
 
-class HTMLViewerApplication : public mojo::Application {
+class HTMLViewerApplication
+    : public mojo::Application,
+      public mojo::InterfaceImpl<mojo::HTMLViewerTestAPI> {
+      //, public mojo::InterfaceFactory<mojo::HTMLViewerTestAPI> {
  public:
   HTMLViewerApplication(InterfaceRequest<Application> request,
                         URLResponsePtr response,
                         scoped_refptr<base::MessageLoopProxy> compositor_thread,
                         WebMediaPlayerFactory* web_media_player_factory,
                         bool is_headless)
       : url_(response->url),
         binding_(this, request.Pass()),
         initial_response_(response.Pass()),
         compositor_thread_(compositor_thread),
         web_media_player_factory_(web_media_player_factory),
         is_headless_(is_headless) {}
 
   void Initialize(ShellPtr shell,
                   Array<String> args,
                   const String& url) override {
+    // std::string test_api_arg "--html_viewer_test_api";
+    // std::vector<std::string> arguments = args.To<std::vector<std::string>>();
+    // if (std::find(arguments.begin(), arguments.end(), test_api_arg) != arguments.end()) {}
+    //ASSERT_TRUE(application_impl()->HasArg("--example_apptest_arg"));
+
+    printf("MSW HTMLViewerApplication::Initialize\n");
     ServiceProviderPtr service_provider;
     shell_ = shell.Pass();
     shell_->ConnectToApplication("mojo:network_service",
                                  GetProxy(&service_provider), nullptr);
     ConnectToService(service_provider.get(), &network_service_);
   }
 
   void AcceptConnection(const String& requestor_url,
                         InterfaceRequest<ServiceProvider> services,
                         ServiceProviderPtr exposed_services,
                         const String& url) override {
+    //service_provider_.AddService<mojo::HTMLViewerTestAPI>(this);
+    service_provider_.Bind(services.Pass());
+
+    printf("MSW HTMLViewerApplication::AcceptConnection "
+           "requestor=[%s] url=[%s] (url_=[%s], initial_response_=[%d])\n",
+           requestor_url.data(), url.data(), url_.data(),
+           !initial_response_.is_null());
+    
     if (initial_response_) {
-      OnResponseReceived(URLLoaderPtr(), services.Pass(),
-                         initial_response_.Pass());
+      OnResponseReceived(URLLoaderPtr(), initial_response_.Pass());
     } else {
+      // TODO(msw): Is this dead code? When is this called? 
       URLLoaderPtr loader;
       network_service_->CreateURLLoader(GetProxy(&loader));
       mojo::URLRequestPtr request(mojo::URLRequest::New());
       request->url = url_;
       request->auto_follow_redirects = true;
 
       // |loader| will be pass 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::Unretained(this), base::Passed(&loader),
-                     base::Passed(&services)));
+                     base::Unretained(this), base::Passed(&loader)));
     }
   }
 
   void RequestQuit() override {}
 
+  //// mojo::InterfaceImpl<mojo::HTMLViewerTestAPI>:
+  // void WaitForHTMLDocument(
+  //     const WaitForHTMLDocumentCallback& callback) override {
+
+  //   // TODO(msw): How can we wait for document load/layout?
+  //   //base::RunLoop run_loop;
+  //   //run_loop.RunUntilIdle();
+  //   //base::MessageLoop::current()->RunUntilIdle();
+  //   //base::MessageLoop::current()->Run();
+
+
+  //   printf("MSW HTMLViewerApplication::WaitForHTMLDocument:%d\n",
+  //          html_document_created_);
+  //   if (html_document_created_) {
+  //     callback.Run();
+  //     return;
+  //   }
+  //   DCHECK(wait_for_html_document_callback_.is_null());
+  //   wait_for_html_document_callback_ = callback;
+  // }
+
+  // // mojo::InterfaceFactory<mojo::HTMLViewerTestAPI>:
+  // void Create(
+  //     ApplicationConnection* connection,
+  //     mojo::InterfaceRequest<mojo::HTMLViewerTestAPI> request) override {
+  //   printf("MSW HTMLViewerApplication::Create (HTMLViewerTestAPI)\n");
+  //   // TODO(msw): Do not offer this service without --html-viewer-test-flag... 
+  //   // TODO(msw): Is this safe/correct? Can we avoid InterfaceFactory? 
+  //   // (getting flaky shutdown crashes w/base::MessageLoop dtor...)
+  //   BindToRequest(this, &request);
+  // }
+
  private:
-  void OnResponseReceived(URLLoaderPtr loader,
-                          InterfaceRequest<ServiceProvider> services,
-                          URLResponsePtr response) {
-    new HTMLDocument(services.Pass(), response.Pass(), shell_.get(),
+  void OnResponseReceived(URLLoaderPtr loader, URLResponsePtr response) {
+    printf("MSW HTMLViewerApplication::OnResponseReceived\n");
+    new HTMLDocument(&service_provider_, response.Pass(), shell_.get(),
                      compositor_thread_, web_media_player_factory_,
                      is_headless_);
+    // html_document_created_ = true;
+    // if (!wait_for_html_document_callback_.is_null())
+    //   wait_for_html_document_callback_.Run();
   }
 
   String url_;
   mojo::StrongBinding<mojo::Application> binding_;
+  mojo::ServiceProviderImpl service_provider_;
   ShellPtr shell_;
   mojo::NetworkServicePtr network_service_;
   URLResponsePtr initial_response_;
   scoped_refptr<base::MessageLoopProxy> compositor_thread_;
   WebMediaPlayerFactory* web_media_player_factory_;
   bool is_headless_;
+  //bool html_document_created_ = false;
+  //WaitForHTMLDocumentCallback wait_for_html_document_callback_;
 };
 
 class ContentHandlerImpl : public mojo::InterfaceImpl<ContentHandler> {
  public:
   ContentHandlerImpl(scoped_refptr<base::MessageLoopProxy> compositor_thread,
                      WebMediaPlayerFactory* web_media_player_factory,
                      bool is_headless)
       : compositor_thread_(compositor_thread),
         web_media_player_factory_(web_media_player_factory),
-        is_headless_(is_headless) {}
+        is_headless_(is_headless) {
+          printf("MSW ContentHandlerImpl::ContentHandlerImpl\n");
+        }
   ~ContentHandlerImpl() override {}
 
  private:
   // Overridden from ContentHandler:
   void StartApplication(InterfaceRequest<mojo::Application> request,
                         URLResponsePtr response) override {
+    printf("MSW ContentHandlerImpl::StartApplication\n");
     new HTMLViewerApplication(request.Pass(), response.Pass(),
                               compositor_thread_, web_media_player_factory_,
                               is_headless_);
   }
 
   scoped_refptr<base::MessageLoopProxy> compositor_thread_;
   WebMediaPlayerFactory* web_media_player_factory_;
   bool is_headless_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl);
@@ skipping 67 matching lines @@
   }
 
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService(this);
     return true;
   }
 
   // Overridden from InterfaceFactory<ContentHandler>
   void Create(ApplicationConnection* connection,
               mojo::InterfaceRequest<ContentHandler> request) override {
+    printf("MSW HTMLViewer::Create (ContentHandler)\n");
     BindToRequest(
         new ContentHandlerImpl(compositor_thread_.message_loop_proxy(),
                                web_media_player_factory_.get(), is_headless_),
         &request);
   }
 
   // Skia requires that we have one of these. Unlike the one used in chrome,
   // this doesn't use purgable shared memory. Instead, it tries to free the
   // oldest unlocked chunks on allocation.
   //
   // TODO(erg): In the long run, delete this allocator and get the real shared
   // memory based purging allocator working here.
   DiscardableMemoryAllocator discardable_memory_allocator_;
 
   scoped_ptr<MojoBlinkPlatformImpl> blink_platform_;
   base::Thread compositor_thread_;
   scoped_ptr<WebMediaPlayerFactory> web_media_player_factory_;
   // Set if the content will never be displayed.
   bool is_headless_;
 
   DISALLOW_COPY_AND_ASSIGN(HTMLViewer);
 };
 
 }  // namespace html_viewer
 
 MojoResult MojoMain(MojoHandle shell_handle) {
+  printf("MSW MojoMain\n");
   mojo::ApplicationRunnerChromium runner(new html_viewer::HTMLViewer);
   return runner.Run(shell_handle);
 }