components/html_viewer/html_widget.cc

   1 // Copyright 2015 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 "components/html_viewer/html_widget.h"
   6
   7 #include "base/command_line.h"
   8 #include "components/html_viewer/global_state.h"
   9 #include "components/html_viewer/ime_controller.h"
  10 #include "components/html_viewer/stats_collection_controller.h"
  11 #include "components/html_viewer/web_layer_tree_view_impl.h"
  12 #include "components/html_viewer/web_storage_namespace_impl.h"
  13 #include "components/mus/public/cpp/view.h"
  14 #include "mojo/application/public/cpp/application_impl.h"
  15 #include "mojo/services/tracing/public/interfaces/tracing.mojom.h"
  16 #include "third_party/WebKit/public/web/WebFrameWidget.h"
  17 #include "third_party/WebKit/public/web/WebSettings.h"
  18 #include "third_party/WebKit/public/web/WebView.h"
  19 #include "ui/gfx/geometry/dip_util.h"
  20
  21 namespace html_viewer {
  22 namespace {
  23
  24 const char kDisableWebGLSwitch[] = "disable-webgl";
  25
  26 scoped_ptr<WebLayerTreeViewImpl> CreateWebLayerTreeView(
  27     GlobalState* global_state) {
  28   return make_scoped_ptr(new WebLayerTreeViewImpl(
  29       global_state->compositor_thread(),
  30       global_state->gpu_memory_buffer_manager(),
  31       global_state->raster_thread_helper()->task_graph_runner()));
  32 }
  33
  34 void InitializeWebLayerTreeView(WebLayerTreeViewImpl* web_layer_tree_view,
  35                                 mojo::ApplicationImpl* app,
  36                                 mus::View* view,
  37                                 blink::WebWidget* widget) {
  38   DCHECK(view);
  39   mojo::URLRequestPtr request(mojo::URLRequest::New());
  40   request->url = mojo::String::From("mojo:mus");
  41   mojo::GpuPtr gpu_service;
  42   app->ConnectToService(request.Pass(), &gpu_service);
  43   web_layer_tree_view->Initialize(gpu_service.Pass(), view, widget);
  44 }
  45
  46 void UpdateWebViewSizeFromViewSize(mus::View* view,
  47                                    blink::WebWidget* web_widget,
  48                                    WebLayerTreeViewImpl* web_layer_tree_view) {
  49   const gfx::Size size_in_pixels(view->bounds().width, view->bounds().height);
  50   const gfx::Size size_in_dips = gfx::ConvertSizeToDIP(
  51       view->viewport_metrics().device_pixel_ratio, size_in_pixels);
  52   web_widget->resize(
  53       blink::WebSize(size_in_dips.width(), size_in_dips.height()));
  54   web_layer_tree_view->setViewportSize(size_in_pixels);
  55 }
  56
  57 void ConfigureSettings(blink::WebSettings* settings) {
  58   settings->setCookieEnabled(true);
  59   settings->setDefaultFixedFontSize(13);
  60   settings->setDefaultFontSize(16);
  61   settings->setLoadsImagesAutomatically(true);
  62   settings->setJavaScriptEnabled(true);
  63
  64   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  65   settings->setExperimentalWebGLEnabled(
  66       !command_line->HasSwitch(kDisableWebGLSwitch));
  67 }
  68
  69 }  // namespace
  70
  71 // HTMLWidgetRootRemote -------------------------------------------------------
  72
  73 HTMLWidgetRootRemote::HTMLWidgetRootRemote()
  74     : web_view_(blink::WebView::create(nullptr)) {
  75   ConfigureSettings(web_view_->settings());
  76 }
  77
  78 HTMLWidgetRootRemote::~HTMLWidgetRootRemote() {}
  79
  80 blink::WebWidget* HTMLWidgetRootRemote::GetWidget() {
  81   return web_view_;
  82 }
  83
  84 void HTMLWidgetRootRemote::OnViewBoundsChanged(mus::View* view) {}
  85
  86 // HTMLWidgetRootLocal --------------------------------------------------------
  87
  88 HTMLWidgetRootLocal::CreateParams::CreateParams(mojo::ApplicationImpl* app,
  89                                                 GlobalState* global_state,
  90                                                 mus::View* view)
  91     : app(app), global_state(global_state), view(view) {}
  92
  93 HTMLWidgetRootLocal::CreateParams::~CreateParams() {}
  94
  95 HTMLWidgetRootLocal::HTMLWidgetRootLocal(CreateParams* create_params)
  96     : app_(create_params->app),
  97       global_state_(create_params->global_state),
  98       view_(create_params->view),
  99       web_view_(nullptr) {
 100   web_view_ = blink::WebView::create(this);
 101   ime_controller_.reset(new ImeController(view_, web_view_));
 102   // Creating the widget calls initializeLayerTreeView() to create the
 103   // |web_layer_tree_view_impl_|. As we haven't yet assigned the |web_view_|
 104   // we have to set it here.
 105   if (web_layer_tree_view_impl_) {
 106     InitializeWebLayerTreeView(web_layer_tree_view_impl_.get(), app_, view_,
 107                                web_view_);
 108     UpdateWebViewSizeFromViewSize(view_, web_view_,
 109                                   web_layer_tree_view_impl_.get());
 110   }
 111   ConfigureSettings(web_view_->settings());
 112 }
 113
 114 HTMLWidgetRootLocal::~HTMLWidgetRootLocal() {}
 115
 116 blink::WebStorageNamespace*
 117 HTMLWidgetRootLocal::createSessionStorageNamespace() {
 118   return new WebStorageNamespaceImpl();
 119 }
 120
 121 void HTMLWidgetRootLocal::initializeLayerTreeView() {
 122   web_layer_tree_view_impl_ = CreateWebLayerTreeView(global_state_);
 123 }
 124
 125 blink::WebLayerTreeView* HTMLWidgetRootLocal::layerTreeView() {
 126   return web_layer_tree_view_impl_.get();
 127 }
 128
 129 void HTMLWidgetRootLocal::didFirstVisuallyNonEmptyLayout() {
 130   static bool called = false;
 131   if (!called) {
 132     const int64 time = base::Time::Now().ToInternalValue();
 133     tracing::StartupPerformanceDataCollectorPtr collector =
 134         StatsCollectionController::ConnectToDataCollector(app_);
 135     if (collector)
 136       collector->SetFirstVisuallyNonEmptyLayoutTime(time);
 137     called = true;
 138   }
 139 }
 140
 141 void HTMLWidgetRootLocal::resetInputMethod() {
 142   ime_controller_->ResetInputMethod();
 143 }
 144
 145 void HTMLWidgetRootLocal::didHandleGestureEvent(
 146     const blink::WebGestureEvent& event,
 147     bool event_cancelled) {
 148   ime_controller_->DidHandleGestureEvent(event, event_cancelled);
 149 }
 150
 151 void HTMLWidgetRootLocal::didUpdateTextOfFocusedElementByNonUserInput() {
 152   ime_controller_->DidUpdateTextOfFocusedElementByNonUserInput();
 153 }
 154
 155 void HTMLWidgetRootLocal::showImeIfNeeded() {
 156   ime_controller_->ShowImeIfNeeded();
 157 }
 158
 159 blink::WebWidget* HTMLWidgetRootLocal::GetWidget() {
 160   return web_view_;
 161 }
 162
 163 void HTMLWidgetRootLocal::OnViewBoundsChanged(mus::View* view) {
 164   UpdateWebViewSizeFromViewSize(view, web_view_,
 165                                 web_layer_tree_view_impl_.get());
 166 }
 167
 168 // HTMLWidgetLocalRoot --------------------------------------------------------
 169
 170 HTMLWidgetLocalRoot::HTMLWidgetLocalRoot(mojo::ApplicationImpl* app,
 171                                          GlobalState* global_state,
 172                                          mus::View* view,
 173                                          blink::WebLocalFrame* web_local_frame)
 174     : app_(app), global_state_(global_state), web_frame_widget_(nullptr) {
 175   web_frame_widget_ = blink::WebFrameWidget::create(this, web_local_frame);
 176   ime_controller_.reset(new ImeController(view, web_frame_widget_));
 177   // Creating the widget calls initializeLayerTreeView() to create the
 178   // |web_layer_tree_view_impl_|. As we haven't yet assigned the
 179   // |web_frame_widget_|
 180   // we have to set it here.
 181   if (web_layer_tree_view_impl_) {
 182     InitializeWebLayerTreeView(web_layer_tree_view_impl_.get(), app_, view,
 183                                web_frame_widget_);
 184     UpdateWebViewSizeFromViewSize(view, web_frame_widget_,
 185                                   web_layer_tree_view_impl_.get());
 186   }
 187 }
 188
 189 HTMLWidgetLocalRoot::~HTMLWidgetLocalRoot() {}
 190
 191 blink::WebWidget* HTMLWidgetLocalRoot::GetWidget() {
 192   return web_frame_widget_;
 193 }
 194
 195 void HTMLWidgetLocalRoot::OnViewBoundsChanged(mus::View* view) {
 196   UpdateWebViewSizeFromViewSize(view, web_frame_widget_,
 197                                 web_layer_tree_view_impl_.get());
 198 }
 199
 200 void HTMLWidgetLocalRoot::initializeLayerTreeView() {
 201   web_layer_tree_view_impl_ = CreateWebLayerTreeView(global_state_);
 202 }
 203
 204 blink::WebLayerTreeView* HTMLWidgetLocalRoot::layerTreeView() {
 205   return web_layer_tree_view_impl_.get();
 206 }
 207
 208 void HTMLWidgetLocalRoot::resetInputMethod() {
 209   ime_controller_->ResetInputMethod();
 210 }
 211
 212 void HTMLWidgetLocalRoot::didHandleGestureEvent(
 213     const blink::WebGestureEvent& event,
 214     bool event_cancelled) {
 215   ime_controller_->DidHandleGestureEvent(event, event_cancelled);
 216 }
 217
 218 void HTMLWidgetLocalRoot::didUpdateTextOfFocusedElementByNonUserInput() {
 219   ime_controller_->DidUpdateTextOfFocusedElementByNonUserInput();
 220 }
 221
 222 void HTMLWidgetLocalRoot::showImeIfNeeded() {
 223   ime_controller_->ShowImeIfNeeded();
 224 }
 225
 226 }  // namespace html_viewer