Make it possible to set the display mode from Chromium

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 "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 251 matching lines @@
   void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
                                   const gfx::Rect& window_screen_rect);
   void OnShowContextMenu(ContextMenuParams* params);
   gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
 
  private:
   void Reapply();
   void Apply(bool top_controls_shrink_blink_size,
              float top_controls_height,
              gfx::Rect resizer_rect,
-             bool is_fullscreen_granted);
+             bool is_fullscreen_granted,
+             blink::WebDisplayMode display_mode);
 
   RenderWidget* widget_;
 
   // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
   WebDeviceEmulationParams params_;
 
   // The computed scale and offset used to fit widget into browser window.
   float scale_;
   gfx::PointF offset_;
 
@@ skipping 17 matching lines @@
       scale_(1.f) {
   original_size_ = widget_->size_;
   original_physical_backing_size_ = widget_->physical_backing_size_;
   original_visible_viewport_size_ = widget_->visible_viewport_size_;
   original_screen_info_ = widget_->screen_info_;
   original_view_screen_rect_ = widget_->view_screen_rect_;
   original_window_screen_rect_ = widget_->window_screen_rect_;
   Apply(widget_->top_controls_shrink_blink_size_,
         widget_->top_controls_height_,
         widget_->resizer_rect_,
-        widget_->is_fullscreen_granted_);
+        widget_->is_fullscreen_granted_,
+        widget_->display_mode_);
 }
 
 RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
   widget_->screen_info_ = original_screen_info_;
 
   widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
   widget_->SetScreenMetricsEmulationParameters(false, params_);
   widget_->view_screen_rect_ = original_view_screen_rect_;
   widget_->window_screen_rect_ = original_window_screen_rect_;
   widget_->Resize(original_size_,
                   original_physical_backing_size_,
                   widget_->top_controls_shrink_blink_size_,
                   widget_->top_controls_height_,
                   original_visible_viewport_size_,
                   widget_->resizer_rect_,
                   widget_->is_fullscreen_granted_,
+                  widget_->display_mode_,
                   NO_RESIZE_ACK);
 }
 
 void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
     const WebDeviceEmulationParams& params) {
   params_ = params;
   Reapply();
 }
 
 void RenderWidget::ScreenMetricsEmulator::Reapply() {
   Apply(widget_->top_controls_shrink_blink_size_,
         widget_->top_controls_height_,
         widget_->resizer_rect_,
-        widget_->is_fullscreen_granted_);
+        widget_->is_fullscreen_granted_,
+        widget_->display_mode_);
 }
 
 void RenderWidget::ScreenMetricsEmulator::Apply(
     bool top_controls_shrink_blink_size,
     float top_controls_height,
     gfx::Rect resizer_rect,
-    bool is_fullscreen_granted) {
+    bool is_fullscreen_granted,
+    blink::WebDisplayMode display_mode) {
   applied_widget_rect_.set_size(gfx::Size(params_.viewSize));
   if (!applied_widget_rect_.width())
     applied_widget_rect_.set_width(original_size_.width());
   if (!applied_widget_rect_.height())
     applied_widget_rect_.set_height(original_size_.height());
 
   if (params_.fitToView && !original_size_.IsEmpty()) {
     int original_width = std::max(original_size_.width(), 1);
     int original_height = std::max(original_size_.height(), 1);
     float width_ratio =
@@ skipping 45 matching lines @@
 
   gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
       original_size_, original_screen_info_.deviceScaleFactor));
   widget_->Resize(applied_widget_rect_.size(),
                   physical_backing_size,
                   top_controls_shrink_blink_size,
                   top_controls_height,
                   applied_widget_rect_.size(),
                   resizer_rect,
                   is_fullscreen_granted,
+                  display_mode,
                   NO_RESIZE_ACK);
 }
 
 void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
     const ViewMsg_Resize_Params& params) {
   bool need_ack = params.new_size != original_size_ &&
       !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
   original_size_ = params.new_size;
   original_physical_backing_size_ = params.physical_backing_size;
   original_screen_info_ = params.screen_info;
   original_visible_viewport_size_ = params.visible_viewport_size;
   Apply(params.top_controls_shrink_blink_size,
         params.top_controls_height,
         params.resizer_rect,
-        params.is_fullscreen_granted);
+        params.is_fullscreen_granted,
+        params.display_mode);
 
   if (need_ack) {
     widget_->set_next_paint_is_resize_ack();
     if (widget_->compositor_)
       widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
   }
 }
 
 void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
     const gfx::Rect& view_screen_rect,
@@ skipping 35 matching lines @@
       init_complete_(false),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0.f),
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
       never_visible_(never_visible),
       is_fullscreen_granted_(false),
+      display_mode_(blink::WebDisplayModeUndefined),
       has_focus_(false),
       handling_input_event_(false),
       handling_ime_event_(false),
       handling_event_type_(WebInputEvent::Undefined),
       ignore_ack_for_mouse_move_from_debugger_(false),
       closing_(false),
       host_closing_(false),
       is_swapped_out_(swapped_out),
       input_method_is_active_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
@@ skipping 272 matching lines @@
   return RenderThread::Get()->Send(message);
 }
 
 void RenderWidget::Resize(const gfx::Size& new_size,
                           const gfx::Size& physical_backing_size,
                           bool top_controls_shrink_blink_size,
                           float top_controls_height,
                           const gfx::Size& visible_viewport_size,
                           const gfx::Rect& resizer_rect,
                           bool is_fullscreen_granted,
+                          blink::WebDisplayMode display_mode,
                           const ResizeAck resize_ack) {
   if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
     // A resize ack shouldn't be requested if we have not ACK'd the previous
     // one.
     DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
     DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
   }
 
   // Ignore this during shutdown.
   if (!webwidget_)
     return;
 
   if (compositor_) {
     compositor_->setViewportSize(new_size, physical_backing_size);
   }
 
   physical_backing_size_ = physical_backing_size;
   top_controls_shrink_blink_size_ = top_controls_shrink_blink_size;
   top_controls_height_ = top_controls_height;
   visible_viewport_size_ = visible_viewport_size;
   resizer_rect_ = resizer_rect;
 
   // NOTE: We may have entered fullscreen mode without changing our size.
   bool fullscreen_change = is_fullscreen_granted_ != is_fullscreen_granted;
   if (fullscreen_change)
     WillToggleFullscreen();
   is_fullscreen_granted_ = is_fullscreen_granted;
+  display_mode_ = display_mode;
 
   webwidget_->setTopControlsHeight(top_controls_height,
                                    top_controls_shrink_blink_size_);
 
   if (size_ != new_size) {
     size_ = new_size;
 
     // When resizing, we want to wait to paint before ACK'ing the resize.  This
     // ensures that we only resize as fast as we can paint.  We only need to
     // send an ACK if we are resized to a non-empty rect.
@@ skipping 25 matching lines @@
 
 void RenderWidget::SetWindowRectSynchronously(
     const gfx::Rect& new_window_rect) {
   Resize(new_window_rect.size(),
          new_window_rect.size(),
          top_controls_shrink_blink_size_,
          top_controls_height_,
          new_window_rect.size(),
          gfx::Rect(),
          is_fullscreen_granted_,
+         display_mode_,
          NO_RESIZE_ACK);
   view_screen_rect_ = new_window_rect;
   window_screen_rect_ = new_window_rect;
   if (!did_show_)
     initial_rect_ = new_window_rect;
 }
 
 void RenderWidget::OnClose() {
   if (closing_)
     return;
@@ skipping 40 matching lines @@
 
   screen_info_ = params.screen_info;
   SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
   Resize(params.new_size,
          params.physical_backing_size,
          params.top_controls_shrink_blink_size,
          params.top_controls_height,
          params.visible_viewport_size,
          params.resizer_rect,
          params.is_fullscreen_granted,
+         params.display_mode,
          params.needs_resize_ack ? SEND_RESIZE_ACK : NO_RESIZE_ACK);
 
   if (orientation_changed)
     OnOrientationChange();
 }
 
 void RenderWidget::OnEnableDeviceEmulation(
    const blink::WebDeviceEmulationParams& params) {
   if (!screen_metrics_emulator_)
     screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
@@ skipping 1511 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content