Check DirectCompositionOverlays field trial only if hardware supports it

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 86 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);
 };
 
+// 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;
+
+  // Before Windows 10 Anniversary Update (Redstone 1), overlay planes
+  // wouldn't be assigned to non-UWP apps.
+  if (base::win::GetVersion() < base::win::VERSION_WIN10_R1)
+    return false;
+
+  base::win::ScopedComPtr<ID3D11Device> d3d11_device =
+      gl::QueryD3D11DeviceObjectFromANGLE();
+  DCHECK(d3d11_device);
+
+  base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
+  d3d11_device.QueryInterface(dxgi_device.Receive());
+  base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
+  dxgi_device->GetAdapter(dxgi_adapter.Receive());
+
+  unsigned int i = 0;
+  while (true) {
+    base::win::ScopedComPtr<IDXGIOutput> output;
+    if (FAILED(dxgi_adapter->EnumOutputs(i++, output.Receive())))
+      break;
+    base::win::ScopedComPtr<IDXGIOutput3> output3;
+    if (FAILED(output.QueryInterface(output3.Receive())))
+      continue;
+
+    UINT flags = 0;
+    if (FAILED(output3->CheckOverlaySupport(DXGI_FORMAT_YUY2,
+                                            d3d11_device.Get(), &flags)))
+      continue;
+
+    // Direct-only support might be ok in some circumstances, but since the
+    // overlay processor isn't set up to try to distinguish, only try to use
+    // overlays when scaling's enabled.
+    if (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;
 
 }  // namespace
 
 class DCLayerTree {
  public:
   DCLayerTree(DirectCompositionSurfaceWin* surface,
@@ skipping 674 matching lines @@
     : gl::GLSurfaceEGL(),
       child_window_(delegate, parent_window),
       vsync_provider_(std::move(vsync_provider)) {}
 
 DirectCompositionSurfaceWin::~DirectCompositionSurfaceWin() {
   Destroy();
 }
 
 // static
 bool DirectCompositionSurfaceWin::AreOverlaysSupported() {
-  if (!base::FeatureList::IsEnabled(switches::kDirectCompositionOverlays))
+  if (!HardwareSupportsOverlays())
     return false;
 
-  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;
-
-  // Before Windows 10 Anniversary Update (Redstone 1), overlay planes
-  // wouldn't be assigned to non-UWP apps.
-  if (base::win::GetVersion() < base::win::VERSION_WIN10_R1)
-    return false;
-
-  base::win::ScopedComPtr<ID3D11Device> d3d11_device =
-      gl::QueryD3D11DeviceObjectFromANGLE();
-  DCHECK(d3d11_device);
-
-  base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
-  d3d11_device.QueryInterface(dxgi_device.Receive());
-  base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
-  dxgi_device->GetAdapter(dxgi_adapter.Receive());
-
-  unsigned int i = 0;
-  while (true) {
-    base::win::ScopedComPtr<IDXGIOutput> output;
-    if (FAILED(dxgi_adapter->EnumOutputs(i++, output.Receive())))
-      break;
-    base::win::ScopedComPtr<IDXGIOutput3> output3;
-    if (FAILED(output.QueryInterface(output3.Receive())))
-      continue;
-
-    UINT flags = 0;
-    if (FAILED(output3->CheckOverlaySupport(DXGI_FORMAT_YUY2,
-                                            d3d11_device.Get(), &flags)))
-      continue;
-
-    // Direct-only support might be ok in some circumstances, but since the
-    // overlay processor isn't set up to try to distinguish, only try to use
-    // overlays when scaling's enabled.
-    if (flags & DXGI_OVERLAY_SUPPORT_FLAG_SCALING)
-      return true;
-  }
-  return false;
+  return base::FeatureList::IsEnabled(switches::kDirectCompositionOverlays);
 }
 
 bool DirectCompositionSurfaceWin::InitializeNativeWindow() {
   if (window_)
     return true;
 
   bool result = child_window_.Initialize();
   window_ = child_window_.window();
   return result;
 }
@@ skipping 307 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