Avoid scaling overlays on systems that don't support them.

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>
@@ skipping 90 matching lines @@
 
  private:
   std::deque<DXGI_FRAME_PRESENTATION_MODE> presents_;
   int composed_count_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(PresentationHistory);
 };
 
 gfx::Size g_overlay_monitor_size;
 
+bool g_supports_scaled_overlays = true;
+
 // 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 37 matching lines @@
     // 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();
+      g_supports_scaled_overlays =
+          !!(flags & DXGI_OVERLAY_SUPPORT_FLAG_SCALING);
       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 327 matching lines @@
   }
 
   // Swap chain size is the minimum of the on-screen size and the source
   // size so the video processor can do the minimal amount of work and
   // the overlay has to read the minimal amount of data.
   // DWM is also less likely to promote a surface to an overlay if it's
   // much larger than its area on-screen.
   gfx::Rect bounds_rect = params.rect;
   gfx::Size ceiled_input_size = gfx::ToCeiledSize(params.contents_rect.size());
   gfx::Size swap_chain_size = bounds_rect.size();
-  swap_chain_size.SetToMin(ceiled_input_size);
+
+  if (g_supports_scaled_overlays)
+    swap_chain_size.SetToMin(ceiled_input_size);
 
   // YUY2 surfaces must have an even width.
   if (swap_chain_size.width() % 2 == 1)
     swap_chain_size.set_width(swap_chain_size.width() + 1);
 
   InitializeVideoProcessor(ceiled_input_size, swap_chain_size);
 
   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
@@ skipping 810 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