Change blink::WebScreenInfo to content::ScreenInfo

content/renderer/render_widget.cc

 // Copyright (c) 2012 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 "content/renderer/render_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 39 matching lines @@
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/render_widget_owner_delegate.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/renderer/resizing_mode_selector.h"
 #include "ipc/ipc_sync_message.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
-#include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/scheduler/renderer/render_widget_scheduling_state.h"
 #include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
 #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
 #include "third_party/WebKit/public/web/WebFrameWidget.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebPagePopup.h"
 #include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
@@ skipping 34 matching lines @@
 using blink::WebKeyboardEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebNavigationPolicy;
 using blink::WebNode;
 using blink::WebPagePopup;
 using blink::WebPoint;
 using blink::WebPopupType;
 using blink::WebRange;
 using blink::WebRect;
-using blink::WebScreenInfo;
 using blink::WebSize;
 using blink::WebTextDirection;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using blink::WebVector;
 using blink::WebWidget;
 
 #define STATIC_ASSERT_ENUM(a, b)                            \
   static_assert(static_cast<int>(a) == static_cast<int>(b), \
                 "mismatching enums: " #a)
@@ skipping 85 matching lines @@
     g_render_widget_initialized = nullptr;
 
 }  // namespace
 
 namespace content {
 
 // RenderWidget ---------------------------------------------------------------
 
 RenderWidget::RenderWidget(CompositorDependencies* compositor_deps,
                            blink::WebPopupType popup_type,
-                           const blink::WebScreenInfo& screen_info,
+                           const ScreenInfo& screen_info,
                            bool swapped_out,
                            bool hidden,
                            bool never_visible)
     : routing_id_(MSG_ROUTING_NONE),
       compositor_deps_(compositor_deps),
       webwidget_(nullptr),
       owner_delegate_(nullptr),
       opener_id_(MSG_ROUTING_NONE),
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
       compositor_never_visible_(never_visible),
       is_fullscreen_granted_(false),
       display_mode_(blink::WebDisplayModeUndefined),
       ime_event_guard_(nullptr),
       closing_(false),
       host_closing_(false),
       is_swapped_out_(swapped_out),
       for_oopif_(false),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       text_input_flags_(0),
       can_compose_inline_(true),
       composition_range_(gfx::Range::InvalidRange()),
       popup_type_(popup_type),
       pending_window_rect_count_(0),
       screen_info_(screen_info),
-      device_scale_factor_(screen_info_.deviceScaleFactor),
+      device_scale_factor_(screen_info_.device_scale_factor),
 #if defined(OS_ANDROID)
       text_field_is_dirty_(false),
 #endif
       monitor_composition_info_(false),
       popup_origin_scale_for_emulation_(0.f),
       frame_swap_message_queue_(new FrameSwapMessageQueue()),
       resizing_mode_selector_(new ResizingModeSelector()),
       has_host_context_menu_location_(false),
       has_focus_(false),
       focused_pepper_plugin_(nullptr) {
@@ skipping 28 matching lines @@
     RenderWidgetInitializedCallback render_widget_initialized) {
   CHECK(!g_create_render_widget && !g_render_widget_initialized);
   g_create_render_widget = create_render_widget;
   g_render_widget_initialized = render_widget_initialized;
 }
 
 // static
 RenderWidget* RenderWidget::Create(int32_t opener_id,
                                    CompositorDependencies* compositor_deps,
                                    blink::WebPopupType popup_type,
-                                   const blink::WebScreenInfo& screen_info) {
+                                   const ScreenInfo& screen_info) {
   DCHECK(opener_id != MSG_ROUTING_NONE);
   scoped_refptr<RenderWidget> widget(new RenderWidget(
       compositor_deps, popup_type, screen_info, false, false, false));
   if (widget->Init(opener_id)) {  // adds reference on success.
     return widget.get();
   }
   return NULL;
 }
 
 // static
 RenderWidget* RenderWidget::CreateForFrame(
     int routing_id,
     bool hidden,
-    const blink::WebScreenInfo& screen_info,
+    const ScreenInfo& screen_info,
     CompositorDependencies* compositor_deps,
     blink::WebLocalFrame* frame) {
   CHECK_NE(routing_id, MSG_ROUTING_NONE);
   // TODO(avi): Before RenderViewImpl has-a RenderWidget, the browser passes the
   // same routing ID for both the view routing ID and the main frame widget
   // routing ID. https://crbug.com/545684
   RenderViewImpl* view = RenderViewImpl::FromRoutingID(routing_id);
   if (view) {
     view->AttachWebFrameWidget(
         RenderWidget::CreateWebFrameWidget(view->GetWidget(), frame));
@@ skipping 121 matching lines @@
 }
 
 void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
     RenderWidgetScreenMetricsEmulator* emulator) {
   popup_origin_scale_for_emulation_ = emulator->scale();
   popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
   popup_screen_origin_for_emulation_ = gfx::Point(
       emulator->original_screen_rect().origin().x() + emulator->offset().x(),
       emulator->original_screen_rect().origin().y() + emulator->offset().y());
   screen_info_ = emulator->original_screen_info();
-  device_scale_factor_ = screen_info_.deviceScaleFactor;
+  device_scale_factor_ = screen_info_.device_scale_factor;
 }
 
 gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
   if (screen_metrics_emulator_)
     return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
   return anchor;
 }
 
 #if defined(USE_EXTERNAL_POPUP_MENU)
 void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
@@ skipping 548 matching lines @@
 
 gfx::Size RenderWidget::GetSizeForWebWidget() const {
   if (IsUseZoomForDSFEnabled())
     return gfx::ScaleToCeiledSize(size_, GetOriginalDeviceScaleFactor());
 
   return size_;
 }
 
 void RenderWidget::Resize(const ResizeParams& params) {
   bool orientation_changed =
-      screen_info_.orientationAngle != params.screen_info.orientationAngle ||
-      screen_info_.orientationType != params.screen_info.orientationType;
+      screen_info_.orientation_angle != params.screen_info.orientation_angle ||
+      screen_info_.orientation_type != params.screen_info.orientation_type;
 
   screen_info_ = params.screen_info;
 
-  if (device_scale_factor_ != screen_info_.deviceScaleFactor) {
-    device_scale_factor_ = screen_info_.deviceScaleFactor;
+  if (device_scale_factor_ != screen_info_.device_scale_factor) {
+    device_scale_factor_ = screen_info_.device_scale_factor;
     OnDeviceScaleFactorChanged();
     ScheduleComposite();
   }
 
   if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
     // A resize ack shouldn't be requested if we have not ACK'd the previous
     // one.
     DCHECK(!params.needs_resize_ack || !next_paint_is_resize_ack());
   }
 
@@ skipping 863 matching lines @@
 }
 
 bool RenderWidget::CanComposeInline() {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_)
     return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents();
 #endif
   return true;
 }
 
-WebScreenInfo RenderWidget::screenInfo() {
-  return screen_info_;
+blink::WebScreenInfo RenderWidget::screenInfo() {
+  blink::WebScreenInfo web_screen_info;
+  web_screen_info.deviceScaleFactor = screen_info_.device_scale_factor;
+  web_screen_info.depth = screen_info_.depth;
+  web_screen_info.depthPerComponent = screen_info_.depth_per_component;
+  web_screen_info.isMonochrome = screen_info_.is_monochrome;
+  web_screen_info.rect = blink::WebRect(screen_info_.rect);
+  web_screen_info.availableRect = blink::WebRect(screen_info_.available_rect);
+  switch (screen_info_.orientation_type) {
+    case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY:
+      web_screen_info.orientationType =
+          blink::WebScreenOrientationPortraitPrimary;
+      break;
+    case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY:
+      web_screen_info.orientationType =
+          blink::WebScreenOrientationPortraitSecondary;
+      break;
+    case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY:
+      web_screen_info.orientationType =
+          blink::WebScreenOrientationLandscapePrimary;
+      break;
+    case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY:
+      web_screen_info.orientationType =
+          blink::WebScreenOrientationLandscapeSecondary;
+      break;
+    default:
+      web_screen_info.orientationType =
+          blink::WebScreenOrientationUndefined;
+      break;
+  }
+  web_screen_info.orientationAngle = screen_info_.orientation_angle;
+  return web_screen_info;
 }
 
 void RenderWidget::resetInputMethod() {
   ImeEventGuard guard(this);
   // If the last text input type is not None, then we should finish any
   // ongoing composition regardless of the new text input type.
   if (text_input_info_.type != blink::WebTextInputTypeNone) {
     // If a composition text exists, then we need to let the browser process
     // to cancel the input method's ongoing composition session.
     if (webwidget_->confirmComposition())
@@ skipping 143 matching lines @@
 #endif  // defined(VIDEO_HOLE)
 
 void RenderWidget::OnWaitNextFrameForTests(int routing_id) {
   QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id),
                MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
 }
 
 float RenderWidget::GetOriginalDeviceScaleFactor() const {
   return
       screen_metrics_emulator_ ?
-      screen_metrics_emulator_->original_screen_info().deviceScaleFactor :
+      screen_metrics_emulator_->original_screen_info().device_scale_factor :
       device_scale_factor_;
 }
 
 bool RenderWidget::requestPointerLock() {
   return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
 }
 
 void RenderWidget::requestPointerUnlock() {
   mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
 }
 
 bool RenderWidget::isPointerLocked() {
   return mouse_lock_dispatcher_->IsMouseLockedTo(
       webwidget_mouse_lock_target_.get());
 }
 
 }  // namespace content