Slightly modify sizes of overlays that are larger than the monitor

gpu/ipc/service/direct_composition_surface_win.cc

 // Copyright 2017 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 "gpu/ipc/service/direct_composition_surface_win.h"
 
 #include <d3d11_1.h>
 #include <dcomptypes.h>
 
 #include <deque>
 
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
+#include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/switches.h"
 #include "ui/display/display_switches.h"
 #include "ui/gfx/color_space_win.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/dc_renderer_layer_params.h"
 #include "ui/gl/egl_util.h"
@@ skipping 68 matching lines @@
   bool valid() const { return presents_.size() >= kPresentsToStore; }
   int composed_count() const { return composed_count_; }
 
  private:
   std::deque<DXGI_FRAME_PRESENTATION_MODE> presents_;
   int composed_count_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(PresentationHistory);
 };
 
+gfx::Size g_overlay_monitor_size;
+
 // This is the raw support info, which shouldn't depend on field trial state.
 bool HardwareSupportsOverlays() {
   if (!gl::GLSurfaceEGL::IsDirectCompositionSupported())
     return false;
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableDirectCompositionLayers))
     return true;
   if (command_line->HasSwitch(switches::kDisableDirectCompositionLayers))
     return false;
@@ skipping 32 matching lines @@
 
     UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.DirectComposition.OverlaySupportFlags",
                                 flags);
 
     // Some new Intel drivers only claim to support unscaled overlays, but
     // scaled overlays still work. Even when scaled overlays aren't actually
     // supported, presentation using the overlay path should be relatively
     // efficient.
     if (flags & (DXGI_OVERLAY_SUPPORT_FLAG_SCALING |
                  DXGI_OVERLAY_SUPPORT_FLAG_DIRECT)) {
+      DXGI_OUTPUT_DESC monitor_desc = {};
+      if (FAILED(output3->GetDesc(&monitor_desc)))
+        continue;
+      g_overlay_monitor_size =
+          gfx::Rect(monitor_desc.DesktopCoordinates).size();
       return true;
     }
   }
   return false;
 }
 
 // Only one DirectComposition surface can be rendered into at a time. Track
 // here which IDCompositionSurface is being rendered into. If another context
 // is made current, then this surface will be suspended.
 IDCompositionSurface* g_current_surface;
@@ skipping 18 matching lines @@
   const base::win::ScopedComPtr<ID3D11VideoProcessor>& video_processor() const {
     return video_processor_;
   }
   const base::win::ScopedComPtr<ID3D11VideoProcessorEnumerator>&
   video_processor_enumerator() const {
     return video_processor_enumerator_;
   }
   base::win::ScopedComPtr<IDXGISwapChain1> GetLayerSwapChainForTesting(
       size_t index) const;
 
+  const GpuDriverBugWorkarounds& workarounds() const {
+    return surface_->workarounds();
+  }
+
  private:
   class SwapChainPresenter;
 
   // This struct is used to cache information about what visuals are currently
   // being presented so that properties that aren't changed aren't sent to
   // DirectComposition.
   struct VisualInfo {
     base::win::ScopedComPtr<IDCompositionVisual2> content_visual;
     base::win::ScopedComPtr<IDCompositionVisual2> clip_visual;
 
@@ skipping 413 matching lines @@
                                                       TRUE, &source_rect);
 
     video_context_->VideoProcessorSetStreamAutoProcessingMode(
         video_processor_.Get(), 0, FALSE);
 
     hr = video_context_->VideoProcessorBlt(video_processor_.Get(),
                                            out_view_.Get(), 0, 1, &stream);
     CHECK(SUCCEEDED(hr));
   }
 
+  if (surface_->workarounds().disable_larger_than_screen_overlays) {
+    // Because of the rounding when converting between pixels and DIPs, a
+    // fullscreen video can become slightly larger than the monitor - e.g. on
+    // a 3000x2000 monitor with a scale factor of 1.75 a 1920x1079 video can
+    // become 3002x1689.
+    // On older Intel drivers, swapchains that are bigger than the monitor
+    // won't be put into overlays, which will hurt power usage a lot. On those
+    // systems, the scaling can be adjusted very slightly so that it's less
+    // than the monitor size. This should be close to imperceptible.
+    // TODO(jbauman): Remove when http://crbug.com/668278 is fixed.
+    const int kOversizeMargin = 3;
+
+    if ((bounds_rect.x() >= 0) &&

[sunnyps, 2017/05/16 00:00:44]

nit: what's the reason for the x/y checks? instead of just checking
width/height?

+        (bounds_rect.width() > g_overlay_monitor_size.width()) &&
+        (bounds_rect.width() <=
+         g_overlay_monitor_size.width() + kOversizeMargin)) {
+      bounds_rect.set_width(g_overlay_monitor_size.width());
+    }
+
+    if ((bounds_rect.y() >= 0) &&
+        (bounds_rect.height() > g_overlay_monitor_size.height()) &&
+        (bounds_rect.height() <=
+         g_overlay_monitor_size.height() + kOversizeMargin)) {
+      bounds_rect.set_height(g_overlay_monitor_size.height());
+    }
+  }
+
   swap_chain_scale_x_ = bounds_rect.width() * 1.0f / swap_chain_size.width();
   swap_chain_scale_y_ = bounds_rect.height() * 1.0f / swap_chain_size.height();
 
   if (first_present) {
     swap_chain_->Present(0, 0);
 
     // DirectComposition can display black for a swapchain between the first
     // and second time it's presented to - maybe the first Present can get
     // lost somehow and it shows the wrong buffer. In that case copy the
     // buffers so both have the correct contents, which seems to help. The
@@ skipping 300 matching lines @@
       base::MakeUnique<ui::DCRendererLayerParams>(params));
   return true;
 }
 
 DirectCompositionSurfaceWin::DirectCompositionSurfaceWin(
     std::unique_ptr<gfx::VSyncProvider> vsync_provider,
     base::WeakPtr<ImageTransportSurfaceDelegate> delegate,
     HWND parent_window)
     : gl::GLSurfaceEGL(),
       child_window_(delegate, parent_window),
+      workarounds_(delegate->GetFeatureInfo()->workarounds()),
       vsync_provider_(std::move(vsync_provider)) {}
 
 DirectCompositionSurfaceWin::~DirectCompositionSurfaceWin() {
   Destroy();
 }
 
 // static
 bool DirectCompositionSurfaceWin::AreOverlaysSupported() {
   if (!HardwareSupportsOverlays())
     return false;
@@ skipping 319 matching lines @@
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DirectCompositionSurfaceWin::GetLayerSwapChainForTesting(size_t index) const {
   return layer_tree_->GetLayerSwapChainForTesting(index);
 }
 
 }  // namespace gpu