mojo/services/html_viewer/html_viewer.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/macros.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/threading/thread.h"
   8 #include "mojo/application/application_runner_chromium.h"
   9 #include "mojo/public/c/system/main.h"
  10 #include "mojo/public/cpp/application/application_connection.h"
  11 #include "mojo/public/cpp/application/application_delegate.h"
  12 #include "mojo/public/cpp/application/application_impl.h"
  13 #include "mojo/public/cpp/application/interface_factory_impl.h"
  14 #include "mojo/services/html_viewer/blink_platform_impl.h"
  15 #include "mojo/services/html_viewer/html_document_view.h"
  16 #include "mojo/services/html_viewer/webmediaplayer_factory.h"
  17 #include "mojo/services/public/interfaces/content_handler/content_handler.mojom.h"
  18 #include "third_party/WebKit/public/web/WebKit.h"
  19
  20 #if !defined(COMPONENT_BUILD)
  21 #include "base/i18n/icu_util.h"
  22 #include "base/path_service.h"
  23 #include "ui/base/resource/resource_bundle.h"
  24 #include "ui/base/ui_base_paths.h"
  25 #endif
  26
  27 namespace mojo {
  28
  29 class HTMLViewer;
  30
  31 class ContentHandlerImpl : public InterfaceImpl<ContentHandler> {
  32  public:
  33   ContentHandlerImpl(Shell* shell,
  34                      scoped_refptr<base::MessageLoopProxy> compositor_thread,
  35                      WebMediaPlayerFactory* web_media_player_factory)
  36       : shell_(shell),
  37         compositor_thread_(compositor_thread),
  38         web_media_player_factory_(web_media_player_factory) {}
  39   virtual ~ContentHandlerImpl() {}
  40
  41  private:
  42   // Overridden from ContentHandler:
  43   virtual void OnConnect(
  44       const mojo::String& requestor_url,
  45       URLResponsePtr response,
  46       InterfaceRequest<ServiceProvider> service_provider_request) override {
  47     new HTMLDocumentView(response.Pass(),
  48                          service_provider_request.Pass(),
  49                          shell_,
  50                          compositor_thread_,
  51                          web_media_player_factory_);
  52   }
  53
  54   Shell* shell_;
  55   scoped_refptr<base::MessageLoopProxy> compositor_thread_;
  56   WebMediaPlayerFactory* web_media_player_factory_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl);
  59 };
  60
  61 class HTMLViewer : public ApplicationDelegate,
  62                    public InterfaceFactory<ContentHandler> {
  63  public:
  64   HTMLViewer() : compositor_thread_("compositor thread") {}
  65
  66   virtual ~HTMLViewer() { blink::shutdown(); }
  67
  68  private:
  69   // Overridden from ApplicationDelegate:
  70   virtual void Initialize(ApplicationImpl* app) override {
  71     shell_ = app->shell();
  72     blink_platform_impl_.reset(new BlinkPlatformImpl(app));
  73     blink::initialize(blink_platform_impl_.get());
  74 #if !defined(COMPONENT_BUILD)
  75   base::i18n::InitializeICU();
  76
  77   ui::RegisterPathProvider();
  78
  79   base::FilePath ui_test_pak_path;
  80   CHECK(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
  81   ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
  82 #endif
  83
  84     compositor_thread_.Start();
  85     web_media_player_factory_.reset(new WebMediaPlayerFactory(
  86         compositor_thread_.message_loop_proxy()));
  87   }
  88
  89   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
  90       override {
  91     connection->AddService(this);
  92     return true;
  93   }
  94
  95   // Overridden from InterfaceFactory<ContentHandler>
  96   virtual void Create(ApplicationConnection* connection,
  97                       InterfaceRequest<ContentHandler> request) override {
  98     BindToRequest(
  99         new ContentHandlerImpl(shell_, compositor_thread_.message_loop_proxy(),
 100                                web_media_player_factory_.get()),
 101         &request);
 102   }
 103
 104   scoped_ptr<BlinkPlatformImpl> blink_platform_impl_;
 105   Shell* shell_;
 106   base::Thread compositor_thread_;
 107   scoped_ptr<WebMediaPlayerFactory> web_media_player_factory_;
 108
 109   DISALLOW_COPY_AND_ASSIGN(HTMLViewer);
 110 };
 111
 112 }  // namespace mojo
 113
 114 MojoResult MojoMain(MojoHandle shell_handle) {
 115   mojo::ApplicationRunnerChromium runner(new mojo::HTMLViewer);
 116   return runner.Run(shell_handle);
 117 }