diff options
Diffstat (limited to 'chromium/ui/gl')
79 files changed, 1726 insertions, 306 deletions
diff --git a/chromium/ui/gl/BUILD.gn b/chromium/ui/gl/BUILD.gn index b707e157ddb..fb084016885 100644 --- a/chromium/ui/gl/BUILD.gn +++ b/chromium/ui/gl/BUILD.gn @@ -4,6 +4,7 @@ import("//build/buildflag_header.gni") import("//build/config/chrome_build.gni") +import("//build/config/chromecast_build.gni") import("//build/config/jumbo.gni") import("//build/config/linux/pkg_config.gni") import("//build/config/ui.gni") @@ -395,6 +396,10 @@ jumbo_component("gl") { deps += [ ":gl_jni_headers" ] } + + if (is_chromecast) { + defines += [ "CHROMECAST_BUILD" ] + } } if (is_mac && use_egl) { diff --git a/chromium/ui/gl/DEPS b/chromium/ui/gl/DEPS index e2673ea5193..1c7a89763c2 100644 --- a/chromium/ui/gl/DEPS +++ b/chromium/ui/gl/DEPS @@ -11,7 +11,7 @@ include_rules = [ specific_include_rules = { # Allow us to include ANGLE's base platform implementation. "angle_platform_impl.cc": [ - "+third_party/angle/include/platform/Platform.h", + "+third_party/angle/include/platform/PlatformMethods.h", ], "direct_composition_surface_win_unittest.cc": [ "+ui/base/win/hidden_window.h", diff --git a/chromium/ui/gl/android/android_surface_control_compat.cc b/chromium/ui/gl/android/android_surface_control_compat.cc index 70a2f706f41..26aebb5dc8f 100644 --- a/chromium/ui/gl/android/android_surface_control_compat.cc +++ b/chromium/ui/gl/android/android_surface_control_compat.cc @@ -11,6 +11,7 @@ #include "base/atomic_sequence_num.h" #include "base/bind.h" #include "base/debug/crash_logging.h" +#include "base/logging.h" #include "base/memory/ptr_util.h" #include "base/no_destructor.h" #include "base/strings/string_number_conversions.h" @@ -49,9 +50,6 @@ using pASurfaceTransaction_delete = void (*)(ASurfaceTransaction*); using pASurfaceTransaction_apply = int64_t (*)(ASurfaceTransaction*); using pASurfaceTransaction_setOnComplete = void (*)(ASurfaceTransaction*, void* ctx, ASurfaceTransaction_OnComplete); -using pASurfaceTransaction_reparent = void (*)(ASurfaceTransaction*, - ASurfaceControl* surface_control, - ASurfaceControl* new_parent); using pASurfaceTransaction_setVisibility = void (*)(ASurfaceTransaction*, ASurfaceControl*, int8_t visibility); @@ -146,7 +144,6 @@ struct SurfaceControlMethods { LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_delete); LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_apply); LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setOnComplete); - LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_reparent); LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setVisibility); LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setZOrder); LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setBuffer); @@ -178,7 +175,6 @@ struct SurfaceControlMethods { pASurfaceTransaction_delete ASurfaceTransaction_deleteFn; pASurfaceTransaction_apply ASurfaceTransaction_applyFn; pASurfaceTransaction_setOnComplete ASurfaceTransaction_setOnCompleteFn; - pASurfaceTransaction_reparent ASurfaceTransaction_reparentFn; pASurfaceTransaction_setVisibility ASurfaceTransaction_setVisibilityFn; pASurfaceTransaction_setZOrder ASurfaceTransaction_setZOrderFn; pASurfaceTransaction_setBuffer ASurfaceTransaction_setBufferFn; @@ -354,14 +350,8 @@ SurfaceControl::Surface::Surface(ANativeWindow* parent, const char* name) { } SurfaceControl::Surface::~Surface() { - if (surface_) { - // It is important to detach the surface from the tree before deleting it. - Transaction transaction; - transaction.SetParent(*this, nullptr); - transaction.Apply(); - + if (surface_) SurfaceControlMethods::Get().ASurfaceControl_releaseFn(surface_); - } } SurfaceControl::SurfaceStats::SurfaceStats() = default; @@ -491,13 +481,6 @@ void SurfaceControl::Transaction::SetOnCompleteCb( transaction_, ack_ctx, &OnTransactionCompletedOnAnyThread); } -void SurfaceControl::Transaction::SetParent(const Surface& surface, - const Surface* new_parent) { - SurfaceControlMethods::Get().ASurfaceTransaction_reparentFn( - transaction_, surface.surface(), - new_parent ? new_parent->surface() : nullptr); -} - void SurfaceControl::Transaction::Apply() { TRACE_EVENT_ASYNC_BEGIN0("gpu,benchmark", "SurfaceControlTransaction", id_); SurfaceControlMethods::Get().ASurfaceTransaction_applyFn(transaction_); diff --git a/chromium/ui/gl/android/android_surface_control_compat.h b/chromium/ui/gl/android/android_surface_control_compat.h index c5baeb7807d..2ee53e69f28 100644 --- a/chromium/ui/gl/android/android_surface_control_compat.h +++ b/chromium/ui/gl/android/android_surface_control_compat.h @@ -130,7 +130,6 @@ class GL_EXPORT SurfaceControl { void SetOnCompleteCb( OnCompleteCb cb, scoped_refptr<base::SingleThreadTaskRunner> task_runner); - void SetParent(const Surface& surface, const Surface* new_parent); void Apply(); diff --git a/chromium/ui/gl/angle_platform_impl.cc b/chromium/ui/gl/angle_platform_impl.cc index 881934cd956..ff4b4a73c12 100644 --- a/chromium/ui/gl/angle_platform_impl.cc +++ b/chromium/ui/gl/angle_platform_impl.cc @@ -5,13 +5,16 @@ #include "ui/gl/angle_platform_impl.h" #include "base/base64.h" +#include "base/bind.h" #include "base/callback.h" #include "base/compiler_specific.h" #include "base/lazy_instance.h" #include "base/metrics/histogram.h" #include "base/metrics/histogram_functions.h" +#include "base/task/post_task.h" +#include "base/task/thread_pool/thread_pool_instance.h" #include "base/trace_event/trace_event.h" -#include "third_party/angle/include/platform/Platform.h" +#include "third_party/angle/include/platform/PlatformMethods.h" #include "ui/gl/gl_bindings.h" namespace angle { @@ -120,6 +123,19 @@ void ANGLEPlatformImpl_histogramBoolean(PlatformMethods* platform, ANGLEPlatformImpl_histogramEnumeration(platform, name, sample ? 1 : 0, 2); } +void ANGLEPlatformImpl_postWorkerTask(PlatformMethods* platform, + PostWorkerTaskCallback callback, + void* user_data) { + base::ThreadPool::PostTask( + FROM_HERE, {base::TaskPriority::USER_VISIBLE}, + base::BindOnce( + [](PostWorkerTaskCallback callback, void* user_data) { + TRACE_EVENT0("toplevel", "ANGLEPlatformImpl::RunWorkerTask"); + callback(user_data); + }, + callback, user_data)); +} + } // anonymous namespace NO_SANITIZE("cfi-icall") @@ -155,6 +171,11 @@ bool InitializePlatform(EGLDisplay display) { ANGLEPlatformImpl_monotonicallyIncreasingTime; platformMethods->updateTraceEventDuration = ANGLEPlatformImpl_updateTraceEventDuration; + + // Initialize the delegate to allow posting tasks in the Chromium thread pool. + // The thread pool is not available in some unittests. + if (base::ThreadPoolInstance::Get()) + platformMethods->postWorkerTask = ANGLEPlatformImpl_postWorkerTask; return true; } diff --git a/chromium/ui/gl/buffer_format_utils.cc b/chromium/ui/gl/buffer_format_utils.cc index d071b415c66..e3947290645 100644 --- a/chromium/ui/gl/buffer_format_utils.cc +++ b/chromium/ui/gl/buffer_format_utils.cc @@ -4,6 +4,7 @@ #include "ui/gl/buffer_format_utils.h" +#include "base/notreached.h" #include "ui/gl/gl_bindings.h" namespace gl { diff --git a/chromium/ui/gl/child_window_win.cc b/chromium/ui/gl/child_window_win.cc index e17931dbb5d..3b9654af9ce 100644 --- a/chromium/ui/gl/child_window_win.cc +++ b/chromium/ui/gl/child_window_win.cc @@ -124,9 +124,9 @@ void DestroyWindowsOnThread(HWND child_window, HWND hidden_popup_window) { ChildWindowWin::ChildWindowWin(HWND parent_window) : parent_window_(parent_window) {} -bool ChildWindowWin::Initialize() { +void ChildWindowWin::Initialize() { if (window_) - return true; + return; thread_ = std::make_unique<base::Thread>("Window owner thread"); base::Thread::Options options(base::MessagePumpType::UI, 0); @@ -143,8 +143,6 @@ bool ChildWindowWin::Initialize() { base::BindOnce(&CreateWindowsOnThread, gfx::Rect(window_rect).size(), &event, &window_, &initial_parent_window_)); event.Wait(); - - return true; } ChildWindowWin::~ChildWindowWin() { diff --git a/chromium/ui/gl/child_window_win.h b/chromium/ui/gl/child_window_win.h index c977e76bdb8..81bd99a8683 100644 --- a/chromium/ui/gl/child_window_win.h +++ b/chromium/ui/gl/child_window_win.h @@ -8,6 +8,7 @@ #include "base/memory/weak_ptr.h" #include "base/task_runner.h" #include "base/threading/thread.h" +#include "ui/gl/gl_export.h" #include <windows.h> @@ -16,12 +17,12 @@ namespace gl { // The window DirectComposition renders into needs to be owned by the process // that's currently doing the rendering. The class creates and owns a window // which is reparented by the browser to be a child of its window. -class ChildWindowWin { +class GL_EXPORT ChildWindowWin { public: explicit ChildWindowWin(HWND parent_window); ~ChildWindowWin(); - bool Initialize(); + void Initialize(); HWND window() const { return window_; } scoped_refptr<base::TaskRunner> GetTaskRunnerForTesting(); diff --git a/chromium/ui/gl/dc_layer_tree.cc b/chromium/ui/gl/dc_layer_tree.cc index b97cf126264..f3548fbca02 100644 --- a/chromium/ui/gl/dc_layer_tree.cc +++ b/chromium/ui/gl/dc_layer_tree.cc @@ -4,8 +4,10 @@ #include "ui/gl/dc_layer_tree.h" +#include "base/metrics/histogram_functions.h" #include "base/trace_event/trace_event.h" #include "ui/gl/direct_composition_child_surface_win.h" +#include "ui/gl/direct_composition_surface_win.h" #include "ui/gl/swap_chain_presenter.h" namespace gl { @@ -63,6 +65,8 @@ bool DCLayerTree::InitializeVideoProcessor(const gfx::Size& input_size, // This can fail if the D3D device is "Microsoft Basic Display Adapter". if (FAILED(d3d11_device_.As(&video_device_))) { DLOG(ERROR) << "Failed to retrieve video device from D3D11 device"; + DCHECK(false); + DirectCompositionSurfaceWin::DisableOverlays(); return false; } DCHECK(video_device_); @@ -97,17 +101,27 @@ bool DCLayerTree::InitializeVideoProcessor(const gfx::Size& input_size, desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL; HRESULT hr = video_device_->CreateVideoProcessorEnumerator( &desc, &video_processor_enumerator_); + base::UmaHistogramSparse( + "GPU.DirectComposition.CreateVideoProcessorEnumerator", hr); if (FAILED(hr)) { DLOG(ERROR) << "CreateVideoProcessorEnumerator failed with error 0x" << std::hex << hr; + // It might fail again next time. Disable overlay support so + // overlay processor will stop sending down overlay frames. + DirectCompositionSurfaceWin::DisableOverlays(); return false; } hr = video_device_->CreateVideoProcessor(video_processor_enumerator_.Get(), 0, &video_processor_); + base::UmaHistogramSparse( + "GPU.DirectComposition.VideoDeviceCreateVideoProcessor", hr); if (FAILED(hr)) { DLOG(ERROR) << "CreateVideoProcessor failed with error 0x" << std::hex << hr; + // It might fail again next time. Disable overlay support so + // overlay processor will stop sending down overlay frames. + DirectCompositionSurfaceWin::DisableOverlays(); return false; } diff --git a/chromium/ui/gl/direct_composition_child_surface_win.cc b/chromium/ui/gl/direct_composition_child_surface_win.cc index 197d9798cb5..4c0c3441eb8 100644 --- a/chromium/ui/gl/direct_composition_child_surface_win.cc +++ b/chromium/ui/gl/direct_composition_child_surface_win.cc @@ -45,6 +45,8 @@ namespace { // is made current, then this surface will be suspended. IDCompositionSurface* g_current_surface = nullptr; +bool g_direct_composition_swap_chain_failed = false; + } // namespace DirectCompositionChildSurfaceWin::DirectCompositionChildSurfaceWin( @@ -282,8 +284,13 @@ bool DirectCompositionChildSurfaceWin::SetDrawRectangle( HRESULT hr = dcomp_device_->CreateSurface( size_.width(), size_.height(), dxgi_format, DXGI_ALPHA_MODE_PREMULTIPLIED, &dcomp_surface_); + base::UmaHistogramSparse("GPU.DirectComposition.DcompDeviceCreateSurface", + hr); if (FAILED(hr)) { DLOG(ERROR) << "CreateSurface failed with error " << std::hex << hr; + // Disable direct composition because CreateSurface might fail again next + // time. + g_direct_composition_swap_chain_failed = true; return false; } } else if (!swap_chain_ && !enable_dc_layers_) { @@ -323,9 +330,17 @@ bool DirectCompositionChildSurfaceWin::SetDrawRectangle( "GPU.DirectComposition.CreateSwapChainForComposition", hr); // If CreateSwapChainForComposition fails, we cannot draw to the - // browser window. Failure here is indicative of an unrecoverable driver - // bug. - CHECK(SUCCEEDED(hr)); + // browser window. Return false after disabling Direct Composition support + // and let the Renderer handle it. Either the GPU command buffer or the GPU + // process will be restarted. + if (FAILED(hr)) { + DLOG(ERROR) << "CreateSwapChainForComposition failed with error " + << std::hex << hr; + // Disable direct composition because SwapChain creation might fail again + // next time. + g_direct_composition_swap_chain_failed = true; + return false; + } Microsoft::WRL::ComPtr<IDXGISwapChain3> swap_chain; if (SUCCEEDED(swap_chain_.As(&swap_chain))) { @@ -458,4 +473,9 @@ bool DirectCompositionChildSurfaceWin::SetEnableDCLayers(bool enable) { return true; } +// static +bool DirectCompositionChildSurfaceWin::IsDirectCompositionSwapChainFailed() { + return g_direct_composition_swap_chain_failed; +} + } // namespace gl diff --git a/chromium/ui/gl/direct_composition_child_surface_win.h b/chromium/ui/gl/direct_composition_child_surface_win.h index 8708087a1dd..98a38f54be9 100644 --- a/chromium/ui/gl/direct_composition_child_surface_win.h +++ b/chromium/ui/gl/direct_composition_child_surface_win.h @@ -38,6 +38,7 @@ class GL_EXPORT DirectCompositionChildSurfaceWin : public GLSurfaceEGL { const gfx::ColorSpace& color_space, bool has_alpha) override; bool SetEnableDCLayers(bool enable) override; + static bool IsDirectCompositionSwapChainFailed(); const Microsoft::WRL::ComPtr<IDCompositionSurface>& dcomp_surface() const { return dcomp_surface_; diff --git a/chromium/ui/gl/direct_composition_surface_win.cc b/chromium/ui/gl/direct_composition_surface_win.cc index 94d32c59d67..7ace65466d0 100644 --- a/chromium/ui/gl/direct_composition_surface_win.cc +++ b/chromium/ui/gl/direct_composition_surface_win.cc @@ -63,19 +63,41 @@ void SetOverlayCapsValid(bool valid) { base::AutoLock auto_lock(GetOverlayLock()); g_overlay_caps_valid = valid; } +// A warpper of IDXGIOutput4::CheckOverlayColorSpaceSupport() +bool CheckOverlayColorSpaceSupport( + DXGI_FORMAT dxgi_format, + DXGI_COLOR_SPACE_TYPE dxgi_color_space, + Microsoft::WRL::ComPtr<IDXGIOutput> output, + Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device) { + UINT color_space_support_flags = 0; + Microsoft::WRL::ComPtr<IDXGIOutput4> output4; + if (FAILED(output.As(&output4)) || + FAILED(output4->CheckOverlayColorSpaceSupport( + dxgi_format, dxgi_color_space, d3d11_device.Get(), + &color_space_support_flags))) + return false; + return (color_space_support_flags & + DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG_PRESENT); +} // Used for workaround limiting overlay size to monitor size. gfx::Size g_overlay_monitor_size; +DirectCompositionSurfaceWin::OverlayHDRInfoUpdateCallback + g_overlay_hdr_gpu_info_callback; + // Preferred overlay format set when detecting overlay support during // initialization. Set to NV12 by default so that it's used when enabling // overlays using command line flags. DXGI_FORMAT g_overlay_format_used = DXGI_FORMAT_NV12; +DXGI_FORMAT g_overlay_format_used_hdr = DXGI_FORMAT_UNKNOWN; // These are the raw support info, which shouldn't depend on field trial state, // or command line flags. UINT g_nv12_overlay_support_flags = 0; UINT g_yuy2_overlay_support_flags = 0; +UINT g_bgra8_overlay_support_flags = 0; +UINT g_rgb10a2_overlay_support_flags = 0; bool FlagsSupportsOverlays(UINT flags) { return (flags & (DXGI_OVERLAY_SUPPORT_FLAG_DIRECT | @@ -84,14 +106,20 @@ bool FlagsSupportsOverlays(UINT flags) { void GetGpuDriverOverlayInfo(bool* supports_overlays, DXGI_FORMAT* overlay_format_used, + DXGI_FORMAT* overlay_format_used_hdr, UINT* nv12_overlay_support_flags, UINT* yuy2_overlay_support_flags, + UINT* bgra8_overlay_support_flags, + UINT* rgb10a2_overlay_support_flags, gfx::Size* overlay_monitor_size) { // Initialization *supports_overlays = false; *overlay_format_used = DXGI_FORMAT_NV12; + *overlay_format_used_hdr = DXGI_FORMAT_R10G10B10A2_UNORM; *nv12_overlay_support_flags = 0; *yuy2_overlay_support_flags = 0; + *bgra8_overlay_support_flags = 0; + *rgb10a2_overlay_support_flags = 0; *overlay_monitor_size = gfx::Size(); // Check for DirectComposition support first to prevent likely crashes. @@ -143,6 +171,13 @@ void GetGpuDriverOverlayInfo(bool* supports_overlays, nv12_overlay_support_flags); output3->CheckOverlaySupport(DXGI_FORMAT_YUY2, d3d11_device.Get(), yuy2_overlay_support_flags); + output3->CheckOverlaySupport(DXGI_FORMAT_B8G8R8A8_UNORM, d3d11_device.Get(), + bgra8_overlay_support_flags); + // Today it still returns false, which blocks Chrome from using HDR + // overlays. + output3->CheckOverlaySupport(DXGI_FORMAT_R10G10B10A2_UNORM, + d3d11_device.Get(), + rgb10a2_overlay_support_flags); if (FlagsSupportsOverlays(*nv12_overlay_support_flags) && base::FeatureList::IsEnabled( features::kDirectCompositionPreferNV12Overlays)) { @@ -152,14 +187,9 @@ void GetGpuDriverOverlayInfo(bool* supports_overlays, // COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 is also supported. Rec 709 is // commonly used for H.264 and HEVC. At least one Intel Gen9 SKU will not // support NV12 overlays. - UINT color_space_support_flags = 0; - Microsoft::WRL::ComPtr<IDXGIOutput4> output4; - if (SUCCEEDED(output.As(&output4)) && - SUCCEEDED(output4->CheckOverlayColorSpaceSupport( + if (CheckOverlayColorSpaceSupport( DXGI_FORMAT_NV12, DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709, - d3d11_device.Get(), &color_space_support_flags)) && - (color_space_support_flags & - DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG_PRESENT)) { + output, d3d11_device)) { // Some new Intel drivers only claim to support unscaled overlays, but // scaled overlays still work. It's possible DWM works around it by // performing an extra scaling Blt before calling the driver. Even when @@ -182,6 +212,15 @@ void GetGpuDriverOverlayInfo(bool* supports_overlays, gfx::Rect(monitor_desc.DesktopCoordinates).size(); } } + // RGB10A2 overlay is used for displaying HDR content. In Intel's + // platform, RGB10A2 overlay is enabled only when + // DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 is supported. + if (FlagsSupportsOverlays(*rgb10a2_overlay_support_flags)) { + if (!CheckOverlayColorSpaceSupport( + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020, output, d3d11_device)) + *rgb10a2_overlay_support_flags = 0; + } // Early out after the first output that reports overlay support. All // outputs are expected to report the same overlay support according to @@ -202,6 +241,8 @@ void GetGpuDriverOverlayInfo(bool* supports_overlays, *supports_overlays = true; *nv12_overlay_support_flags = 0; *yuy2_overlay_support_flags = 0; + *bgra8_overlay_support_flags = 0; + *rgb10a2_overlay_support_flags = 0; // Software overlays always use NV12 because it's slightly more efficient and // YUY2 was only used because Skylake doesn't support NV12 hardware overlays. @@ -219,13 +260,18 @@ void UpdateOverlaySupport() { bool supports_overlays = false; DXGI_FORMAT overlay_format_used = DXGI_FORMAT_NV12; + DXGI_FORMAT overlay_format_used_hdr = DXGI_FORMAT_R10G10B10A2_UNORM; UINT nv12_overlay_support_flags = 0; UINT yuy2_overlay_support_flags = 0; + UINT bgra8_overlay_support_flags = 0; + UINT rgb10a2_overlay_support_flags = 0; gfx::Size overlay_monitor_size = gfx::Size(); - GetGpuDriverOverlayInfo(&supports_overlays, &overlay_format_used, - &nv12_overlay_support_flags, - &yuy2_overlay_support_flags, &overlay_monitor_size); + GetGpuDriverOverlayInfo( + &supports_overlays, &overlay_format_used, &overlay_format_used_hdr, + &nv12_overlay_support_flags, &yuy2_overlay_support_flags, + &bgra8_overlay_support_flags, &rgb10a2_overlay_support_flags, + &overlay_monitor_size); if (supports_overlays != SupportsOverlays() || overlay_format_used != g_overlay_format_used) { @@ -241,8 +287,11 @@ void UpdateOverlaySupport() { // Update global caps SetSupportsOverlays(supports_overlays); g_overlay_format_used = overlay_format_used; + g_overlay_format_used_hdr = overlay_format_used_hdr; g_nv12_overlay_support_flags = nv12_overlay_support_flags; g_yuy2_overlay_support_flags = yuy2_overlay_support_flags; + g_bgra8_overlay_support_flags = bgra8_overlay_support_flags; + g_rgb10a2_overlay_support_flags = rgb10a2_overlay_support_flags; g_overlay_monitor_size = overlay_monitor_size; } @@ -257,6 +306,11 @@ bool SupportsLowLatencyPresentation() { features::kDirectCompositionLowLatencyPresentation) && SupportsPresentationFeedback(); } + +void RunOverlayHdrGpuInfoUpdateCallback() { + if (g_overlay_hdr_gpu_info_callback) + g_overlay_hdr_gpu_info_callback.Run(); +} } // namespace DirectCompositionSurfaceWin::PendingFrame::PendingFrame( @@ -351,7 +405,8 @@ bool DirectCompositionSurfaceWin::IsDirectCompositionSupported() { return true; }(); - return supported; + return supported && !DirectCompositionChildSurfaceWin:: + IsDirectCompositionSwapChainFailed(); } // static @@ -384,6 +439,7 @@ bool DirectCompositionSurfaceWin::IsDecodeSwapChainSupported() { // static void DirectCompositionSurfaceWin::DisableOverlays() { SetSupportsOverlays(false); + RunOverlayHdrGpuInfoUpdateCallback(); } // static @@ -407,10 +463,25 @@ bool DirectCompositionSurfaceWin::AreScaledOverlaysSupported() { // static UINT DirectCompositionSurfaceWin::GetOverlaySupportFlags(DXGI_FORMAT format) { UpdateOverlaySupport(); - if (format == DXGI_FORMAT_NV12) - return g_nv12_overlay_support_flags; - DCHECK_EQ(DXGI_FORMAT_YUY2, format); - return g_yuy2_overlay_support_flags; + UINT support_flag = 0; + switch (format) { + case DXGI_FORMAT_NV12: + support_flag = g_nv12_overlay_support_flags; + break; + case DXGI_FORMAT_YUY2: + support_flag = g_yuy2_overlay_support_flags; + break; + case DXGI_FORMAT_B8G8R8A8_UNORM: + support_flag = g_bgra8_overlay_support_flags; + break; + case DXGI_FORMAT_R10G10B10A2_UNORM: + support_flag = g_rgb10a2_overlay_support_flags; + break; + default: + NOTREACHED(); + break; + } + return support_flag; } // static @@ -430,9 +501,11 @@ void DirectCompositionSurfaceWin::SetScaledOverlaysSupportedForTesting( if (supported) { g_nv12_overlay_support_flags |= DXGI_OVERLAY_SUPPORT_FLAG_SCALING; g_yuy2_overlay_support_flags |= DXGI_OVERLAY_SUPPORT_FLAG_SCALING; + g_rgb10a2_overlay_support_flags |= DXGI_OVERLAY_SUPPORT_FLAG_SCALING; } else { g_nv12_overlay_support_flags &= ~DXGI_OVERLAY_SUPPORT_FLAG_SCALING; g_yuy2_overlay_support_flags &= ~DXGI_OVERLAY_SUPPORT_FLAG_SCALING; + g_rgb10a2_overlay_support_flags &= ~DXGI_OVERLAY_SUPPORT_FLAG_SCALING; } DCHECK_EQ(supported, AreScaledOverlaysSupported()); } @@ -457,8 +530,8 @@ bool DirectCompositionSurfaceWin::IsHDRSupported() { return false; HRESULT hr = S_OK; - Microsoft::WRL::ComPtr<IDXGIFactory> factory; - hr = CreateDXGIFactory(IID_PPV_ARGS(&factory)); + Microsoft::WRL::ComPtr<IDXGIFactory1> factory; + hr = CreateDXGIFactory1(IID_PPV_ARGS(&factory)); if (FAILED(hr)) { DLOG(ERROR) << "Failed to create DXGI factory."; return false; @@ -556,6 +629,12 @@ bool DirectCompositionSurfaceWin::AllowTearing() { DirectCompositionSurfaceWin::IsSwapChainTearingSupported(); } +// static +void DirectCompositionSurfaceWin::SetOverlayHDRGpuInfoUpdateCallback( + OverlayHDRInfoUpdateCallback callback) { + g_overlay_hdr_gpu_info_callback = std::move(callback); +} + bool DirectCompositionSurfaceWin::Initialize(GLSurfaceFormat format) { d3d11_device_ = QueryD3D11DeviceObjectFromANGLE(); if (!d3d11_device_) { @@ -570,10 +649,8 @@ bool DirectCompositionSurfaceWin::Initialize(GLSurfaceFormat format) { return false; } - if (!child_window_.Initialize()) { - DLOG(ERROR) << "Failed to initialize native window"; - return false; - } + child_window_.Initialize(); + window_ = child_window_.window(); if (!layer_tree_->Initialize(window_, d3d11_device_, dcomp_device_)) @@ -719,7 +796,13 @@ bool DirectCompositionSurfaceWin::SupportsProtectedVideo() const { } bool DirectCompositionSurfaceWin::SetDrawRectangle(const gfx::Rect& rectangle) { - return root_surface_->SetDrawRectangle(rectangle); + bool result = root_surface_->SetDrawRectangle(rectangle); + if (!result && + DirectCompositionChildSurfaceWin::IsDirectCompositionSwapChainFailed()) { + RunOverlayHdrGpuInfoUpdateCallback(); + } + + return result; } gfx::Vector2d DirectCompositionSurfaceWin::GetDrawOffset() const { @@ -847,11 +930,13 @@ void DirectCompositionSurfaceWin::OnGpuSwitched( void DirectCompositionSurfaceWin::OnDisplayAdded() { InvalidateOverlayCaps(); UpdateOverlaySupport(); + RunOverlayHdrGpuInfoUpdateCallback(); } void DirectCompositionSurfaceWin::OnDisplayRemoved() { InvalidateOverlayCaps(); UpdateOverlaySupport(); + RunOverlayHdrGpuInfoUpdateCallback(); } scoped_refptr<base::TaskRunner> diff --git a/chromium/ui/gl/direct_composition_surface_win.h b/chromium/ui/gl/direct_composition_surface_win.h index aeef4c28d6f..82d17af5964 100644 --- a/chromium/ui/gl/direct_composition_surface_win.h +++ b/chromium/ui/gl/direct_composition_surface_win.h @@ -31,6 +31,8 @@ class GL_EXPORT DirectCompositionSurfaceWin : public GLSurfaceEGL, using VSyncCallback = base::RepeatingCallback<void(base::TimeTicks, base::TimeDelta)>; + using OverlayHDRInfoUpdateCallback = base::RepeatingClosure; + struct Settings { bool disable_nv12_dynamic_textures = false; bool disable_larger_than_screen_overlays = false; @@ -92,6 +94,9 @@ class GL_EXPORT DirectCompositionSurfaceWin : public GLSurfaceEGL, static void SetOverlayFormatUsedForTesting(DXGI_FORMAT format); + static void SetOverlayHDRGpuInfoUpdateCallback( + OverlayHDRInfoUpdateCallback callback); + // GLSurfaceEGL implementation. bool Initialize(GLSurfaceFormat format) override; void Destroy() override; diff --git a/chromium/ui/gl/egl_bindings_autogen_mock.cc b/chromium/ui/gl/egl_bindings_autogen_mock.cc index d4d3a043df9..a8045b39904 100644 --- a/chromium/ui/gl/egl_bindings_autogen_mock.cc +++ b/chromium/ui/gl/egl_bindings_autogen_mock.cc @@ -10,6 +10,7 @@ #include <string.h> +#include "base/notreached.h" #include "ui/gl/egl_mock.h" namespace { @@ -355,6 +356,12 @@ MockEGLInterface::Mock_eglGetSyncValuesCHROMIUM(EGLDisplay dpy, return interface_->GetSyncValuesCHROMIUM(dpy, surface, ust, msc, sbc); } +void GL_BINDING_CALL +MockEGLInterface::Mock_eglHandleGPUSwitchANGLE(EGLDisplay dpy) { + MakeEglMockFunctionUnique("eglHandleGPUSwitchANGLE"); + interface_->HandleGPUSwitchANGLE(dpy); +} + EGLBoolean GL_BINDING_CALL MockEGLInterface::Mock_eglImageFlushExternalEXT(EGLDisplay dpy, EGLImageKHR image, @@ -492,6 +499,20 @@ MockEGLInterface::Mock_eglQuerySurfacePointerANGLE(EGLDisplay dpy, return interface_->QuerySurfacePointerANGLE(dpy, surface, attribute, value); } +void GL_BINDING_CALL +MockEGLInterface::Mock_eglReacquireHighPowerGPUANGLE(EGLDisplay dpy, + EGLContext ctx) { + MakeEglMockFunctionUnique("eglReacquireHighPowerGPUANGLE"); + interface_->ReacquireHighPowerGPUANGLE(dpy, ctx); +} + +void GL_BINDING_CALL +MockEGLInterface::Mock_eglReleaseHighPowerGPUANGLE(EGLDisplay dpy, + EGLContext ctx) { + MakeEglMockFunctionUnique("eglReleaseHighPowerGPUANGLE"); + interface_->ReleaseHighPowerGPUANGLE(dpy, ctx); +} + EGLBoolean GL_BINDING_CALL MockEGLInterface::Mock_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, @@ -723,6 +744,9 @@ MockEGLInterface::GetGLProcAddress(const char* name) { if (strcmp(name, "eglGetSyncValuesCHROMIUM") == 0) return reinterpret_cast<GLFunctionPointerType>( Mock_eglGetSyncValuesCHROMIUM); + if (strcmp(name, "eglHandleGPUSwitchANGLE") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_eglHandleGPUSwitchANGLE); if (strcmp(name, "eglImageFlushExternalEXT") == 0) return reinterpret_cast<GLFunctionPointerType>( Mock_eglImageFlushExternalEXT); @@ -761,6 +785,12 @@ MockEGLInterface::GetGLProcAddress(const char* name) { if (strcmp(name, "eglQuerySurfacePointerANGLE") == 0) return reinterpret_cast<GLFunctionPointerType>( Mock_eglQuerySurfacePointerANGLE); + if (strcmp(name, "eglReacquireHighPowerGPUANGLE") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_eglReacquireHighPowerGPUANGLE); + if (strcmp(name, "eglReleaseHighPowerGPUANGLE") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_eglReleaseHighPowerGPUANGLE); if (strcmp(name, "eglReleaseTexImage") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_eglReleaseTexImage); if (strcmp(name, "eglReleaseThread") == 0) diff --git a/chromium/ui/gl/egl_bindings_autogen_mock.h b/chromium/ui/gl/egl_bindings_autogen_mock.h index 4b7eb01109b..61840ea51d6 100644 --- a/chromium/ui/gl/egl_bindings_autogen_mock.h +++ b/chromium/ui/gl/egl_bindings_autogen_mock.h @@ -157,6 +157,7 @@ Mock_eglGetSyncValuesCHROMIUM(EGLDisplay dpy, EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, EGLuint64CHROMIUM* sbc); +static void GL_BINDING_CALL Mock_eglHandleGPUSwitchANGLE(EGLDisplay dpy); static EGLBoolean GL_BINDING_CALL Mock_eglImageFlushExternalEXT(EGLDisplay dpy, EGLImageKHR image, @@ -217,6 +218,10 @@ Mock_eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void** value); +static void GL_BINDING_CALL Mock_eglReacquireHighPowerGPUANGLE(EGLDisplay dpy, + EGLContext ctx); +static void GL_BINDING_CALL Mock_eglReleaseHighPowerGPUANGLE(EGLDisplay dpy, + EGLContext ctx); static EGLBoolean GL_BINDING_CALL Mock_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer); diff --git a/chromium/ui/gl/generate_bindings.py b/chromium/ui/gl/generate_bindings.py index c682b59b2d0..4b02fa80d3d 100755 --- a/chromium/ui/gl/generate_bindings.py +++ b/chromium/ui/gl/generate_bindings.py @@ -160,16 +160,49 @@ GL_FUNCTIONS = [ 'names': ['glBlendEquation'], 'arguments': ' GLenum mode ', }, { 'return_type': 'void', + 'known_as': 'glBlendEquationiOES', + 'versions': [ + { 'name': 'glBlendEquationi' }, + { 'name': 'glBlendEquationiOES', 'extensions': + ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': ' GLuint buf, GLenum mode ', }, +{ 'return_type': 'void', 'names': ['glBlendEquationSeparate'], 'arguments': 'GLenum modeRGB, GLenum modeAlpha', }, { 'return_type': 'void', + 'known_as': 'glBlendEquationSeparateiOES', + 'versions': [ + { 'name': 'glBlendEquationSeparatei' }, + { 'name': 'glBlendEquationSeparateiOES', 'extensions': + ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': 'GLuint buf, GLenum modeRGB, GLenum modeAlpha', }, +{ 'return_type': 'void', 'names': ['glBlendFunc'], 'arguments': 'GLenum sfactor, GLenum dfactor', }, { 'return_type': 'void', + 'known_as': 'glBlendFunciOES', + 'versions': [ + { 'name': 'glBlendFunci' }, + { 'name': 'glBlendFunciOES', 'extensions': ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': 'GLuint buf, GLenum sfactor, GLenum dfactor', }, +{ 'return_type': 'void', 'names': ['glBlendFuncSeparate'], 'arguments': 'GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha', }, { 'return_type': 'void', + 'known_as': 'glBlendFuncSeparateiOES', + 'versions': [ + { 'name': 'glBlendFuncSeparatei' }, + { 'name': 'glBlendFuncSeparateiOES', 'extensions': + ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': + 'GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, ' + 'GLenum dstAlpha', }, +{ 'return_type': 'void', 'versions' : [{'name': 'glBlitFramebuffer', 'extensions': ['GL_ARB_framebuffer_object']}, {'name': 'glBlitFramebufferANGLE'}, @@ -251,6 +284,15 @@ GL_FUNCTIONS = [ 'arguments': 'GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha', }, { 'return_type': 'void', + 'known_as': 'glColorMaskiOES', + 'versions': [ + { 'name': 'glColorMaski' }, + { 'name': 'glColorMaskiOES', 'extensions': ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': + 'GLuint buf, GLboolean red, GLboolean green, GLboolean blue, ' + 'GLboolean alpha', }, +{ 'return_type': 'void', 'names': ['glCompileShader'], 'arguments': 'GLuint shader', }, { 'return_type': 'void', @@ -513,6 +555,13 @@ GL_FUNCTIONS = [ 'extensions': ['GL_ANGLE_request_extension'] }], 'arguments': 'const char* name', }, { 'return_type': 'void', + 'known_as': 'glDisableiOES', + 'versions': [ + { 'name': 'glDisablei' }, + { 'name': 'glDisableiOES', 'extensions': ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': 'GLenum target, GLuint index', }, +{ 'return_type': 'void', 'names': ['glDisableVertexAttribArray'], 'arguments': 'GLuint index', }, { 'return_type': 'void', @@ -592,6 +641,13 @@ GL_FUNCTIONS = [ 'names': ['glEnable'], 'arguments': 'GLenum cap', }, { 'return_type': 'void', + 'known_as': 'glEnableiOES', + 'versions': [ + { 'name': 'glEnablei' }, + { 'name': 'glEnableiOES', 'extensions': ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': 'GLenum target, GLuint index', }, +{ 'return_type': 'void', 'names': ['glEnableVertexAttribArray'], 'arguments': 'GLuint index', }, { 'return_type': 'void', @@ -1335,6 +1391,13 @@ GL_FUNCTIONS = [ 'names': ['glIsEnabled'], 'arguments': 'GLenum cap', }, { 'return_type': 'GLboolean', + 'known_as': 'glIsEnablediOES', + 'versions': [ + { 'name': 'glIsEnabledi' }, + { 'name': 'glIsEnablediOES', 'extensions': ['GL_OES_draw_buffers_indexed'] } + ], + 'arguments': 'GLenum target, GLuint index', }, +{ 'return_type': 'GLboolean', 'known_as': 'glIsFenceAPPLE', 'versions': [{ 'name': 'glIsFenceAPPLE', 'extensions': ['GL_APPLE_fence'] }], @@ -1501,6 +1564,9 @@ GL_FUNCTIONS = [ 'extensions': ['GL_KHR_debug'] }], 'arguments': 'void* ptr, GLsizei length, const char* label', }, { 'return_type': 'void', + 'names': ['glPatchParameteri'], + 'arguments': 'GLenum pname, GLint value', }, +{ 'return_type': 'void', 'names': ['glPathCommandsNV'], 'versions': [{ 'name': 'glPathCommandsNV', 'extensions': ['GL_NV_path_rendering'] }, @@ -2505,6 +2571,10 @@ EGL_FUNCTIONS = [ 'EGLDisplay dpy, EGLSurface surface, ' 'EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, ' 'EGLuint64CHROMIUM* sbc', }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'eglHandleGPUSwitchANGLE', + 'extensions': ['EGL_ANGLE_power_preference'] }], + 'arguments': 'EGLDisplay dpy' }, { 'return_type': 'EGLBoolean', 'versions': [{ 'name': 'eglImageFlushExternalEXT', 'extensions': ['EGL_EXT_image_flush_external'] }], @@ -2581,6 +2651,14 @@ EGL_FUNCTIONS = [ 'names': ['eglQuerySurfacePointerANGLE'], 'arguments': 'EGLDisplay dpy, EGLSurface surface, EGLint attribute, void** value', }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'eglReacquireHighPowerGPUANGLE', + 'extensions': ['EGL_ANGLE_power_preference'] }], + 'arguments': 'EGLDisplay dpy, EGLContext ctx' }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'eglReleaseHighPowerGPUANGLE', + 'extensions': ['EGL_ANGLE_power_preference'] }], + 'arguments': 'EGLDisplay dpy, EGLContext ctx' }, { 'return_type': 'EGLBoolean', 'names': ['eglReleaseTexImage'], 'arguments': 'EGLDisplay dpy, EGLSurface surface, EGLint buffer', }, @@ -3586,6 +3664,7 @@ def GenerateMockBindingsSource(file, functions, set_name): #include <string.h> +#include "base/notreached.h" #include "ui/gl/%s_mock.h" namespace { diff --git a/chromium/ui/gl/gl_bindings.h b/chromium/ui/gl/gl_bindings.h index 8fb6b5c16d2..85e92fc5865 100644 --- a/chromium/ui/gl/gl_bindings.h +++ b/chromium/ui/gl/gl_bindings.h @@ -418,6 +418,17 @@ #define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT 0x88FC #endif /* GL_EXT_blend_func_extended */ +#ifndef GL_OES_draw_buffers_indexed +#define GL_OES_draw_buffers_indexed 1 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_COLOR_WRITEMASK 0x0C23 +#endif /* GL_OES_draw_buffers_indexed */ + #ifndef GL_EXT_window_rectangles #define GL_EXT_window_rectangles 1 #define GL_INCLUSIVE_EXT 0x8F10 @@ -448,6 +459,7 @@ #define GL_CHROMIUM_shared_image 1 #define GL_SHARED_IMAGE_ACCESS_MODE_READ_CHROMIUM 0x8AF6 #define GL_SHARED_IMAGE_ACCESS_MODE_READWRITE_CHROMIUM 0x8AF7 +#define GL_SHARED_IMAGE_ACCESS_MODE_OVERLAY_CHROMIUM 0x8AF8 #endif /* GL_CHROMIUM_shared_image */ #ifndef GL_NV_internalformat_sample_query diff --git a/chromium/ui/gl/gl_bindings_api_autogen_egl.h b/chromium/ui/gl/gl_bindings_api_autogen_egl.h index 30b0ba80492..ff1e581ee70 100644 --- a/chromium/ui/gl/gl_bindings_api_autogen_egl.h +++ b/chromium/ui/gl/gl_bindings_api_autogen_egl.h @@ -134,6 +134,7 @@ EGLBoolean eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy, EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, EGLuint64CHROMIUM* sbc) override; +void eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) override; EGLBoolean eglImageFlushExternalEXTFn(EGLDisplay dpy, EGLImageKHR image, const EGLAttrib* attrib_list) override; @@ -188,6 +189,8 @@ EGLBoolean eglQuerySurfacePointerANGLEFn(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void** value) override; +void eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy, EGLContext ctx) override; +void eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy, EGLContext ctx) override; EGLBoolean eglReleaseTexImageFn(EGLDisplay dpy, EGLSurface surface, EGLint buffer) override; diff --git a/chromium/ui/gl/gl_bindings_api_autogen_gl.h b/chromium/ui/gl/gl_bindings_api_autogen_gl.h index 50f66d83266..102e3f99a87 100644 --- a/chromium/ui/gl/gl_bindings_api_autogen_gl.h +++ b/chromium/ui/gl/gl_bindings_api_autogen_gl.h @@ -64,12 +64,22 @@ void glBlendColorFn(GLclampf red, GLclampf blue, GLclampf alpha) override; void glBlendEquationFn(GLenum mode) override; +void glBlendEquationiOESFn(GLuint buf, GLenum mode) override; void glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) override; +void glBlendEquationSeparateiOESFn(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) override; void glBlendFuncFn(GLenum sfactor, GLenum dfactor) override; +void glBlendFunciOESFn(GLuint buf, GLenum sfactor, GLenum dfactor) override; void glBlendFuncSeparateFn(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override; +void glBlendFuncSeparateiOESFn(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) override; void glBlitFramebufferFn(GLint srcX0, GLint srcY0, GLint srcX1, @@ -136,6 +146,11 @@ void glColorMaskFn(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override; +void glColorMaskiOESFn(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) override; void glCompileShaderFn(GLuint shader) override; void glCompressedTexImage2DFn(GLenum target, GLint level, @@ -334,6 +349,7 @@ void glDepthRangefFn(GLclampf zNear, GLclampf zFar) override; void glDetachShaderFn(GLuint program, GLuint shader) override; void glDisableFn(GLenum cap) override; void glDisableExtensionANGLEFn(const char* name) override; +void glDisableiOESFn(GLenum target, GLuint index) override; void glDisableVertexAttribArrayFn(GLuint index) override; void glDiscardFramebufferEXTFn(GLenum target, GLsizei numAttachments, @@ -386,6 +402,7 @@ void glEGLImageTargetRenderbufferStorageOESFn(GLenum target, void glEGLImageTargetTexture2DOESFn(GLenum target, GLeglImageOES image) override; void glEnableFn(GLenum cap) override; +void glEnableiOESFn(GLenum target, GLuint index) override; void glEnableVertexAttribArrayFn(GLuint index) override; void glEndQueryFn(GLenum target) override; void glEndTilingQCOMFn(GLbitfield preserveMask) override; @@ -912,6 +929,7 @@ void glInvalidateSubFramebufferFn(GLenum target, void glInvalidateTextureANGLEFn(GLenum target) override; GLboolean glIsBufferFn(GLuint buffer) override; GLboolean glIsEnabledFn(GLenum cap) override; +GLboolean glIsEnablediOESFn(GLenum target, GLuint index) override; GLboolean glIsFenceAPPLEFn(GLuint fence) override; GLboolean glIsFenceNVFn(GLuint fence) override; GLboolean glIsFramebufferEXTFn(GLuint framebuffer) override; @@ -984,6 +1002,7 @@ void glObjectLabelFn(GLenum identifier, GLsizei length, const char* label) override; void glObjectPtrLabelFn(void* ptr, GLsizei length, const char* label) override; +void glPatchParameteriFn(GLenum pname, GLint value) override; void glPathCommandsNVFn(GLuint path, GLsizei numCommands, const GLubyte* commands, diff --git a/chromium/ui/gl/gl_bindings_autogen_egl.cc b/chromium/ui/gl/gl_bindings_autogen_egl.cc index 184442231da..43135771bd0 100644 --- a/chromium/ui/gl/gl_bindings_autogen_egl.cc +++ b/chromium/ui/gl/gl_bindings_autogen_egl.cc @@ -181,6 +181,8 @@ void DriverEGL::InitializeExtensionBindings() { gfx::HasExtension(extensions, "EGL_ANDROID_native_fence_sync"); ext.b_EGL_ANGLE_d3d_share_handle_client_buffer = gfx::HasExtension(extensions, "EGL_ANGLE_d3d_share_handle_client_buffer"); + ext.b_EGL_ANGLE_power_preference = + gfx::HasExtension(extensions, "EGL_ANGLE_power_preference"); ext.b_EGL_ANGLE_query_surface_pointer = gfx::HasExtension(extensions, "EGL_ANGLE_query_surface_pointer"); ext.b_EGL_ANGLE_stream_producer_d3d_texture = @@ -303,6 +305,12 @@ void DriverEGL::InitializeExtensionBindings() { GetGLProcAddress("eglGetSyncValuesCHROMIUM")); } + if (ext.b_EGL_ANGLE_power_preference) { + fn.eglHandleGPUSwitchANGLEFn = + reinterpret_cast<eglHandleGPUSwitchANGLEProc>( + GetGLProcAddress("eglHandleGPUSwitchANGLE")); + } + if (ext.b_EGL_EXT_image_flush_external) { fn.eglImageFlushExternalEXTFn = reinterpret_cast<eglImageFlushExternalEXTProc>( @@ -330,6 +338,18 @@ void DriverEGL::InitializeExtensionBindings() { GetGLProcAddress("eglQuerySurfacePointerANGLE")); } + if (ext.b_EGL_ANGLE_power_preference) { + fn.eglReacquireHighPowerGPUANGLEFn = + reinterpret_cast<eglReacquireHighPowerGPUANGLEProc>( + GetGLProcAddress("eglReacquireHighPowerGPUANGLE")); + } + + if (ext.b_EGL_ANGLE_power_preference) { + fn.eglReleaseHighPowerGPUANGLEFn = + reinterpret_cast<eglReleaseHighPowerGPUANGLEProc>( + GetGLProcAddress("eglReleaseHighPowerGPUANGLE")); + } + if (ext.b_EGL_ANDROID_blob_cache) { fn.eglSetBlobCacheFuncsANDROIDFn = reinterpret_cast<eglSetBlobCacheFuncsANDROIDProc>( @@ -649,6 +669,10 @@ EGLBoolean EGLApiBase::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy, return driver_->fn.eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc); } +void EGLApiBase::eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) { + driver_->fn.eglHandleGPUSwitchANGLEFn(dpy); +} + EGLBoolean EGLApiBase::eglImageFlushExternalEXTFn( EGLDisplay dpy, EGLImageKHR image, @@ -756,6 +780,15 @@ EGLBoolean EGLApiBase::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy, value); } +void EGLApiBase::eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy, + EGLContext ctx) { + driver_->fn.eglReacquireHighPowerGPUANGLEFn(dpy, ctx); +} + +void EGLApiBase::eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy, EGLContext ctx) { + driver_->fn.eglReleaseHighPowerGPUANGLEFn(dpy, ctx); +} + EGLBoolean EGLApiBase::eglReleaseTexImageFn(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { @@ -1171,6 +1204,11 @@ EGLBoolean TraceEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy, return egl_api_->eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc); } +void TraceEGLApi::eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglHandleGPUSwitchANGLE") + egl_api_->eglHandleGPUSwitchANGLEFn(dpy); +} + EGLBoolean TraceEGLApi::eglImageFlushExternalEXTFn( EGLDisplay dpy, EGLImageKHR image, @@ -1297,6 +1335,20 @@ EGLBoolean TraceEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy, value); } +void TraceEGLApi::eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy, + EGLContext ctx) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", + "TraceEGLAPI::eglReacquireHighPowerGPUANGLE") + egl_api_->eglReacquireHighPowerGPUANGLEFn(dpy, ctx); +} + +void TraceEGLApi::eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy, + EGLContext ctx) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", + "TraceEGLAPI::eglReleaseHighPowerGPUANGLE") + egl_api_->eglReleaseHighPowerGPUANGLEFn(dpy, ctx); +} + EGLBoolean TraceEGLApi::eglReleaseTexImageFn(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { @@ -1901,6 +1953,12 @@ EGLBoolean LogEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy, return result; } +void LogEGLApi::eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) { + GL_SERVICE_LOG("eglHandleGPUSwitchANGLE" + << "(" << dpy << ")"); + egl_api_->eglHandleGPUSwitchANGLEFn(dpy); +} + EGLBoolean LogEGLApi::eglImageFlushExternalEXTFn(EGLDisplay dpy, EGLImageKHR image, const EGLAttrib* attrib_list) { @@ -2098,6 +2156,19 @@ EGLBoolean LogEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy, return result; } +void LogEGLApi::eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy, + EGLContext ctx) { + GL_SERVICE_LOG("eglReacquireHighPowerGPUANGLE" + << "(" << dpy << ", " << ctx << ")"); + egl_api_->eglReacquireHighPowerGPUANGLEFn(dpy, ctx); +} + +void LogEGLApi::eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy, EGLContext ctx) { + GL_SERVICE_LOG("eglReleaseHighPowerGPUANGLE" + << "(" << dpy << ", " << ctx << ")"); + egl_api_->eglReleaseHighPowerGPUANGLEFn(dpy, ctx); +} + EGLBoolean LogEGLApi::eglReleaseTexImageFn(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { diff --git a/chromium/ui/gl/gl_bindings_autogen_egl.h b/chromium/ui/gl/gl_bindings_autogen_egl.h index 6cafd14601f..538fff97cf1 100644 --- a/chromium/ui/gl/gl_bindings_autogen_egl.h +++ b/chromium/ui/gl/gl_bindings_autogen_egl.h @@ -168,6 +168,7 @@ typedef EGLBoolean(GL_BINDING_CALL* eglGetSyncValuesCHROMIUMProc)( EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, EGLuint64CHROMIUM* sbc); +typedef void(GL_BINDING_CALL* eglHandleGPUSwitchANGLEProc)(EGLDisplay dpy); typedef EGLBoolean(GL_BINDING_CALL* eglImageFlushExternalEXTProc)( EGLDisplay dpy, EGLImageKHR image, @@ -230,6 +231,11 @@ typedef EGLBoolean(GL_BINDING_CALL* eglQuerySurfacePointerANGLEProc)( EGLSurface surface, EGLint attribute, void** value); +typedef void(GL_BINDING_CALL* eglReacquireHighPowerGPUANGLEProc)( + EGLDisplay dpy, + EGLContext ctx); +typedef void(GL_BINDING_CALL* eglReleaseHighPowerGPUANGLEProc)(EGLDisplay dpy, + EGLContext ctx); typedef EGLBoolean(GL_BINDING_CALL* eglReleaseTexImageProc)(EGLDisplay dpy, EGLSurface surface, EGLint buffer); @@ -293,6 +299,7 @@ struct ExtensionsEGL { bool b_EGL_ANDROID_get_native_client_buffer; bool b_EGL_ANDROID_native_fence_sync; bool b_EGL_ANGLE_d3d_share_handle_client_buffer; + bool b_EGL_ANGLE_power_preference; bool b_EGL_ANGLE_query_surface_pointer; bool b_EGL_ANGLE_stream_producer_d3d_texture; bool b_EGL_ANGLE_surface_d3d_texture_2d_share_handle; @@ -359,6 +366,7 @@ struct ProcsEGL { eglGetProcAddressProc eglGetProcAddressFn; eglGetSyncAttribKHRProc eglGetSyncAttribKHRFn; eglGetSyncValuesCHROMIUMProc eglGetSyncValuesCHROMIUMFn; + eglHandleGPUSwitchANGLEProc eglHandleGPUSwitchANGLEFn; eglImageFlushExternalEXTProc eglImageFlushExternalEXTFn; eglInitializeProc eglInitializeFn; eglLabelObjectKHRProc eglLabelObjectKHRFn; @@ -376,6 +384,8 @@ struct ProcsEGL { eglQueryStringiANGLEProc eglQueryStringiANGLEFn; eglQuerySurfaceProc eglQuerySurfaceFn; eglQuerySurfacePointerANGLEProc eglQuerySurfacePointerANGLEFn; + eglReacquireHighPowerGPUANGLEProc eglReacquireHighPowerGPUANGLEFn; + eglReleaseHighPowerGPUANGLEProc eglReleaseHighPowerGPUANGLEFn; eglReleaseTexImageProc eglReleaseTexImageFn; eglReleaseThreadProc eglReleaseThreadFn; eglSetBlobCacheFuncsANDROIDProc eglSetBlobCacheFuncsANDROIDFn; @@ -536,6 +546,7 @@ class GL_EXPORT EGLApi { EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, EGLuint64CHROMIUM* sbc) = 0; + virtual void eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) = 0; virtual EGLBoolean eglImageFlushExternalEXTFn( EGLDisplay dpy, EGLImageKHR image, @@ -591,6 +602,10 @@ class GL_EXPORT EGLApi { EGLSurface surface, EGLint attribute, void** value) = 0; + virtual void eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy, + EGLContext ctx) = 0; + virtual void eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy, + EGLContext ctx) = 0; virtual EGLBoolean eglReleaseTexImageFn(EGLDisplay dpy, EGLSurface surface, EGLint buffer) = 0; @@ -697,6 +712,8 @@ class GL_EXPORT EGLApi { #define eglGetSyncAttribKHR ::gl::g_current_egl_context->eglGetSyncAttribKHRFn #define eglGetSyncValuesCHROMIUM \ ::gl::g_current_egl_context->eglGetSyncValuesCHROMIUMFn +#define eglHandleGPUSwitchANGLE \ + ::gl::g_current_egl_context->eglHandleGPUSwitchANGLEFn #define eglImageFlushExternalEXT \ ::gl::g_current_egl_context->eglImageFlushExternalEXTFn #define eglInitialize ::gl::g_current_egl_context->eglInitializeFn @@ -718,6 +735,10 @@ class GL_EXPORT EGLApi { #define eglQuerySurface ::gl::g_current_egl_context->eglQuerySurfaceFn #define eglQuerySurfacePointerANGLE \ ::gl::g_current_egl_context->eglQuerySurfacePointerANGLEFn +#define eglReacquireHighPowerGPUANGLE \ + ::gl::g_current_egl_context->eglReacquireHighPowerGPUANGLEFn +#define eglReleaseHighPowerGPUANGLE \ + ::gl::g_current_egl_context->eglReleaseHighPowerGPUANGLEFn #define eglReleaseTexImage ::gl::g_current_egl_context->eglReleaseTexImageFn #define eglReleaseThread ::gl::g_current_egl_context->eglReleaseThreadFn #define eglSetBlobCacheFuncsANDROID \ diff --git a/chromium/ui/gl/gl_bindings_autogen_gl.cc b/chromium/ui/gl/gl_bindings_autogen_gl.cc index 67d468b0c34..96a8926f7cb 100644 --- a/chromium/ui/gl/gl_bindings_autogen_gl.cc +++ b/chromium/ui/gl/gl_bindings_autogen_gl.cc @@ -447,6 +447,8 @@ void DriverGL::InitializeDynamicBindings(const GLVersionInfo* ver, ext.b_GL_NV_path_rendering = gfx::HasExtension(extensions, "GL_NV_path_rendering"); ext.b_GL_OES_EGL_image = gfx::HasExtension(extensions, "GL_OES_EGL_image"); + ext.b_GL_OES_draw_buffers_indexed = + gfx::HasExtension(extensions, "GL_OES_draw_buffers_indexed"); ext.b_GL_OES_get_program_binary = gfx::HasExtension(extensions, "GL_OES_get_program_binary"); ext.b_GL_OES_mapbuffer = gfx::HasExtension(extensions, "GL_OES_mapbuffer"); @@ -600,6 +602,42 @@ void DriverGL::InitializeDynamicBindings(const GLVersionInfo* ver, GetGLProcAddress("glBlendBarrierKHR")); } + if (ver->IsAtLeastGLES(3u, 2u) || ver->IsAtLeastGL(4u, 0u)) { + fn.glBlendEquationiOESFn = reinterpret_cast<glBlendEquationiOESProc>( + GetGLProcAddress("glBlendEquationi")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glBlendEquationiOESFn = reinterpret_cast<glBlendEquationiOESProc>( + GetGLProcAddress("glBlendEquationiOES")); + } + + if (ver->IsAtLeastGLES(3u, 2u) || ver->IsAtLeastGL(4u, 0u)) { + fn.glBlendEquationSeparateiOESFn = + reinterpret_cast<glBlendEquationSeparateiOESProc>( + GetGLProcAddress("glBlendEquationSeparatei")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glBlendEquationSeparateiOESFn = + reinterpret_cast<glBlendEquationSeparateiOESProc>( + GetGLProcAddress("glBlendEquationSeparateiOES")); + } + + if (ver->IsAtLeastGLES(3u, 2u) || ver->IsAtLeastGL(4u, 0u)) { + fn.glBlendFunciOESFn = + reinterpret_cast<glBlendFunciOESProc>(GetGLProcAddress("glBlendFunci")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glBlendFunciOESFn = reinterpret_cast<glBlendFunciOESProc>( + GetGLProcAddress("glBlendFunciOES")); + } + + if (ver->IsAtLeastGLES(3u, 2u) || ver->IsAtLeastGL(4u, 0u)) { + fn.glBlendFuncSeparateiOESFn = + reinterpret_cast<glBlendFuncSeparateiOESProc>( + GetGLProcAddress("glBlendFuncSeparatei")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glBlendFuncSeparateiOESFn = + reinterpret_cast<glBlendFuncSeparateiOESProc>( + GetGLProcAddress("glBlendFuncSeparateiOES")); + } + if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) || ext.b_GL_ARB_framebuffer_object) { fn.glBlitFramebufferFn = reinterpret_cast<glBlitFramebufferProc>( @@ -674,6 +712,14 @@ void DriverGL::InitializeDynamicBindings(const GLVersionInfo* ver, GetGLProcAddress("glClientWaitSyncAPPLE")); } + if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 2u)) { + fn.glColorMaskiOESFn = + reinterpret_cast<glColorMaskiOESProc>(GetGLProcAddress("glColorMaski")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glColorMaskiOESFn = reinterpret_cast<glColorMaskiOESProc>( + GetGLProcAddress("glColorMaskiOES")); + } + if (ext.b_GL_ANGLE_robust_client_memory) { fn.glCompressedTexImage2DRobustANGLEFn = reinterpret_cast<glCompressedTexImage2DRobustANGLEProc>( @@ -926,6 +972,14 @@ void DriverGL::InitializeDynamicBindings(const GLVersionInfo* ver, GetGLProcAddress("glDisableExtensionANGLE")); } + if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 2u)) { + fn.glDisableiOESFn = + reinterpret_cast<glDisableiOESProc>(GetGLProcAddress("glDisablei")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glDisableiOESFn = + reinterpret_cast<glDisableiOESProc>(GetGLProcAddress("glDisableiOES")); + } + if (ext.b_GL_EXT_discard_framebuffer) { fn.glDiscardFramebufferEXTFn = reinterpret_cast<glDiscardFramebufferEXTProc>( @@ -1042,6 +1096,14 @@ void DriverGL::InitializeDynamicBindings(const GLVersionInfo* ver, GetGLProcAddress("glEGLImageTargetTexture2DOES")); } + if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 2u)) { + fn.glEnableiOESFn = + reinterpret_cast<glEnableiOESProc>(GetGLProcAddress("glEnablei")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glEnableiOESFn = + reinterpret_cast<glEnableiOESProc>(GetGLProcAddress("glEnableiOES")); + } + if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) { fn.glEndQueryFn = reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQuery")); @@ -1897,6 +1959,14 @@ void DriverGL::InitializeDynamicBindings(const GLVersionInfo* ver, GetGLProcAddress("glInvalidateTextureANGLE")); } + if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 2u)) { + fn.glIsEnablediOESFn = + reinterpret_cast<glIsEnablediOESProc>(GetGLProcAddress("glIsEnabledi")); + } else if (ext.b_GL_OES_draw_buffers_indexed) { + fn.glIsEnablediOESFn = reinterpret_cast<glIsEnablediOESProc>( + GetGLProcAddress("glIsEnablediOES")); + } + if (ext.b_GL_APPLE_fence) { fn.glIsFenceAPPLEFn = reinterpret_cast<glIsFenceAPPLEProc>( GetGLProcAddress("glIsFenceAPPLE")); @@ -2103,6 +2173,11 @@ void DriverGL::InitializeDynamicBindings(const GLVersionInfo* ver, GetGLProcAddress("glObjectPtrLabelKHR")); } + if (ver->IsAtLeastGLES(3u, 2u) || ver->IsAtLeastGL(4u, 0u)) { + fn.glPatchParameteriFn = reinterpret_cast<glPatchParameteriProc>( + GetGLProcAddress("glPatchParameteri")); + } + if (ext.b_GL_NV_path_rendering) { fn.glPathCommandsNVFn = reinterpret_cast<glPathCommandsNVProc>( GetGLProcAddress("glPathCommandsNV")); @@ -3067,14 +3142,28 @@ void GLApiBase::glBlendEquationFn(GLenum mode) { driver_->fn.glBlendEquationFn(mode); } +void GLApiBase::glBlendEquationiOESFn(GLuint buf, GLenum mode) { + driver_->fn.glBlendEquationiOESFn(buf, mode); +} + void GLApiBase::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) { driver_->fn.glBlendEquationSeparateFn(modeRGB, modeAlpha); } +void GLApiBase::glBlendEquationSeparateiOESFn(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) { + driver_->fn.glBlendEquationSeparateiOESFn(buf, modeRGB, modeAlpha); +} + void GLApiBase::glBlendFuncFn(GLenum sfactor, GLenum dfactor) { driver_->fn.glBlendFuncFn(sfactor, dfactor); } +void GLApiBase::glBlendFunciOESFn(GLuint buf, GLenum sfactor, GLenum dfactor) { + driver_->fn.glBlendFunciOESFn(buf, sfactor, dfactor); +} + void GLApiBase::glBlendFuncSeparateFn(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, @@ -3082,6 +3171,15 @@ void GLApiBase::glBlendFuncSeparateFn(GLenum srcRGB, driver_->fn.glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha); } +void GLApiBase::glBlendFuncSeparateiOESFn(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) { + driver_->fn.glBlendFuncSeparateiOESFn(buf, srcRGB, dstRGB, srcAlpha, + dstAlpha); +} + void GLApiBase::glBlitFramebufferFn(GLint srcX0, GLint srcY0, GLint srcX1, @@ -3204,6 +3302,14 @@ void GLApiBase::glColorMaskFn(GLboolean red, driver_->fn.glColorMaskFn(red, green, blue, alpha); } +void GLApiBase::glColorMaskiOESFn(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) { + driver_->fn.glColorMaskiOESFn(buf, red, green, blue, alpha); +} + void GLApiBase::glCompileShaderFn(GLuint shader) { driver_->fn.glCompileShaderFn(shader); } @@ -3589,6 +3695,10 @@ void GLApiBase::glDisableExtensionANGLEFn(const char* name) { driver_->fn.glDisableExtensionANGLEFn(name); } +void GLApiBase::glDisableiOESFn(GLenum target, GLuint index) { + driver_->fn.glDisableiOESFn(target, index); +} + void GLApiBase::glDisableVertexAttribArrayFn(GLuint index) { driver_->fn.glDisableVertexAttribArrayFn(index); } @@ -3698,6 +3808,10 @@ void GLApiBase::glEnableFn(GLenum cap) { driver_->fn.glEnableFn(cap); } +void GLApiBase::glEnableiOESFn(GLenum target, GLuint index) { + driver_->fn.glEnableiOESFn(target, index); +} + void GLApiBase::glEnableVertexAttribArrayFn(GLuint index) { driver_->fn.glEnableVertexAttribArrayFn(index); } @@ -4790,6 +4904,10 @@ GLboolean GLApiBase::glIsEnabledFn(GLenum cap) { return driver_->fn.glIsEnabledFn(cap); } +GLboolean GLApiBase::glIsEnablediOESFn(GLenum target, GLuint index) { + return driver_->fn.glIsEnablediOESFn(target, index); +} + GLboolean GLApiBase::glIsFenceAPPLEFn(GLuint fence) { return driver_->fn.glIsFenceAPPLEFn(fence); } @@ -4973,6 +5091,10 @@ void GLApiBase::glObjectPtrLabelFn(void* ptr, driver_->fn.glObjectPtrLabelFn(ptr, length, label); } +void GLApiBase::glPatchParameteriFn(GLenum pname, GLint value) { + driver_->fn.glPatchParameteriFn(pname, value); +} + void GLApiBase::glPathCommandsNVFn(GLuint path, GLsizei numCommands, const GLubyte* commands, @@ -6395,16 +6517,34 @@ void TraceGLApi::glBlendEquationFn(GLenum mode) { gl_api_->glBlendEquationFn(mode); } +void TraceGLApi::glBlendEquationiOESFn(GLuint buf, GLenum mode) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendEquationiOES") + gl_api_->glBlendEquationiOESFn(buf, mode); +} + void TraceGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendEquationSeparate") gl_api_->glBlendEquationSeparateFn(modeRGB, modeAlpha); } +void TraceGLApi::glBlendEquationSeparateiOESFn(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", + "TraceGLAPI::glBlendEquationSeparateiOES") + gl_api_->glBlendEquationSeparateiOESFn(buf, modeRGB, modeAlpha); +} + void TraceGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendFunc") gl_api_->glBlendFuncFn(sfactor, dfactor); } +void TraceGLApi::glBlendFunciOESFn(GLuint buf, GLenum sfactor, GLenum dfactor) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendFunciOES") + gl_api_->glBlendFunciOESFn(buf, sfactor, dfactor); +} + void TraceGLApi::glBlendFuncSeparateFn(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, @@ -6413,6 +6553,15 @@ void TraceGLApi::glBlendFuncSeparateFn(GLenum srcRGB, gl_api_->glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha); } +void TraceGLApi::glBlendFuncSeparateiOESFn(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendFuncSeparateiOES") + gl_api_->glBlendFuncSeparateiOESFn(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + void TraceGLApi::glBlitFramebufferFn(GLint srcX0, GLint srcY0, GLint srcX1, @@ -6554,6 +6703,15 @@ void TraceGLApi::glColorMaskFn(GLboolean red, gl_api_->glColorMaskFn(red, green, blue, alpha); } +void TraceGLApi::glColorMaskiOESFn(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glColorMaskiOES") + gl_api_->glColorMaskiOESFn(buf, red, green, blue, alpha); +} + void TraceGLApi::glCompileShaderFn(GLuint shader) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCompileShader") gl_api_->glCompileShaderFn(shader); @@ -6998,6 +7156,11 @@ void TraceGLApi::glDisableExtensionANGLEFn(const char* name) { gl_api_->glDisableExtensionANGLEFn(name); } +void TraceGLApi::glDisableiOESFn(GLenum target, GLuint index) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDisableiOES") + gl_api_->glDisableiOESFn(target, index); +} + void TraceGLApi::glDisableVertexAttribArrayFn(GLuint index) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDisableVertexAttribArray") gl_api_->glDisableVertexAttribArrayFn(index); @@ -7130,6 +7293,11 @@ void TraceGLApi::glEnableFn(GLenum cap) { gl_api_->glEnableFn(cap); } +void TraceGLApi::glEnableiOESFn(GLenum target, GLuint index) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEnableiOES") + gl_api_->glEnableiOESFn(target, index); +} + void TraceGLApi::glEnableVertexAttribArrayFn(GLuint index) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEnableVertexAttribArray") gl_api_->glEnableVertexAttribArrayFn(index); @@ -8421,6 +8589,11 @@ GLboolean TraceGLApi::glIsEnabledFn(GLenum cap) { return gl_api_->glIsEnabledFn(cap); } +GLboolean TraceGLApi::glIsEnablediOESFn(GLenum target, GLuint index) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsEnablediOES") + return gl_api_->glIsEnablediOESFn(target, index); +} + GLboolean TraceGLApi::glIsFenceAPPLEFn(GLuint fence) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFenceAPPLE") return gl_api_->glIsFenceAPPLEFn(fence); @@ -8645,6 +8818,11 @@ void TraceGLApi::glObjectPtrLabelFn(void* ptr, gl_api_->glObjectPtrLabelFn(ptr, length, label); } +void TraceGLApi::glPatchParameteriFn(GLenum pname, GLint value) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPatchParameteri") + gl_api_->glPatchParameteriFn(pname, value); +} + void TraceGLApi::glPathCommandsNVFn(GLuint path, GLsizei numCommands, const GLubyte* commands, @@ -10308,6 +10486,12 @@ void LogGLApi::glBlendEquationFn(GLenum mode) { gl_api_->glBlendEquationFn(mode); } +void LogGLApi::glBlendEquationiOESFn(GLuint buf, GLenum mode) { + GL_SERVICE_LOG("glBlendEquationiOES" + << "(" << buf << ", " << GLEnums::GetStringEnum(mode) << ")"); + gl_api_->glBlendEquationiOESFn(buf, mode); +} + void LogGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) { GL_SERVICE_LOG("glBlendEquationSeparate" << "(" << GLEnums::GetStringEnum(modeRGB) << ", " @@ -10315,6 +10499,15 @@ void LogGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) { gl_api_->glBlendEquationSeparateFn(modeRGB, modeAlpha); } +void LogGLApi::glBlendEquationSeparateiOESFn(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) { + GL_SERVICE_LOG("glBlendEquationSeparateiOES" + << "(" << buf << ", " << GLEnums::GetStringEnum(modeRGB) + << ", " << GLEnums::GetStringEnum(modeAlpha) << ")"); + gl_api_->glBlendEquationSeparateiOESFn(buf, modeRGB, modeAlpha); +} + void LogGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) { GL_SERVICE_LOG("glBlendFunc" << "(" << GLEnums::GetStringEnum(sfactor) << ", " @@ -10322,6 +10515,13 @@ void LogGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) { gl_api_->glBlendFuncFn(sfactor, dfactor); } +void LogGLApi::glBlendFunciOESFn(GLuint buf, GLenum sfactor, GLenum dfactor) { + GL_SERVICE_LOG("glBlendFunciOES" + << "(" << buf << ", " << GLEnums::GetStringEnum(sfactor) + << ", " << GLEnums::GetStringEnum(dfactor) << ")"); + gl_api_->glBlendFunciOESFn(buf, sfactor, dfactor); +} + void LogGLApi::glBlendFuncSeparateFn(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, @@ -10334,6 +10534,19 @@ void LogGLApi::glBlendFuncSeparateFn(GLenum srcRGB, gl_api_->glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha); } +void LogGLApi::glBlendFuncSeparateiOESFn(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) { + GL_SERVICE_LOG("glBlendFuncSeparateiOES" + << "(" << buf << ", " << GLEnums::GetStringEnum(srcRGB) << ", " + << GLEnums::GetStringEnum(dstRGB) << ", " + << GLEnums::GetStringEnum(srcAlpha) << ", " + << GLEnums::GetStringEnum(dstAlpha) << ")"); + gl_api_->glBlendFuncSeparateiOESFn(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + void LogGLApi::glBlitFramebufferFn(GLint srcX0, GLint srcY0, GLint srcX1, @@ -10523,6 +10736,19 @@ void LogGLApi::glColorMaskFn(GLboolean red, gl_api_->glColorMaskFn(red, green, blue, alpha); } +void LogGLApi::glColorMaskiOESFn(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) { + GL_SERVICE_LOG("glColorMaskiOES" + << "(" << buf << ", " << GLEnums::GetStringBool(red) << ", " + << GLEnums::GetStringBool(green) << ", " + << GLEnums::GetStringBool(blue) << ", " + << GLEnums::GetStringBool(alpha) << ")"); + gl_api_->glColorMaskiOESFn(buf, red, green, blue, alpha); +} + void LogGLApi::glCompileShaderFn(GLuint shader) { GL_SERVICE_LOG("glCompileShader" << "(" << shader << ")"); @@ -11105,6 +11331,13 @@ void LogGLApi::glDisableExtensionANGLEFn(const char* name) { gl_api_->glDisableExtensionANGLEFn(name); } +void LogGLApi::glDisableiOESFn(GLenum target, GLuint index) { + GL_SERVICE_LOG("glDisableiOES" + << "(" << GLEnums::GetStringEnum(target) << ", " << index + << ")"); + gl_api_->glDisableiOESFn(target, index); +} + void LogGLApi::glDisableVertexAttribArrayFn(GLuint index) { GL_SERVICE_LOG("glDisableVertexAttribArray" << "(" << index << ")"); @@ -11271,6 +11504,13 @@ void LogGLApi::glEnableFn(GLenum cap) { gl_api_->glEnableFn(cap); } +void LogGLApi::glEnableiOESFn(GLenum target, GLuint index) { + GL_SERVICE_LOG("glEnableiOES" + << "(" << GLEnums::GetStringEnum(target) << ", " << index + << ")"); + gl_api_->glEnableiOESFn(target, index); +} + void LogGLApi::glEnableVertexAttribArrayFn(GLuint index) { GL_SERVICE_LOG("glEnableVertexAttribArray" << "(" << index << ")"); @@ -12976,6 +13216,15 @@ GLboolean LogGLApi::glIsEnabledFn(GLenum cap) { return result; } +GLboolean LogGLApi::glIsEnablediOESFn(GLenum target, GLuint index) { + GL_SERVICE_LOG("glIsEnablediOES" + << "(" << GLEnums::GetStringEnum(target) << ", " << index + << ")"); + GLboolean result = gl_api_->glIsEnablediOESFn(target, index); + GL_SERVICE_LOG("GL_RESULT: " << result); + return result; +} + GLboolean LogGLApi::glIsFenceAPPLEFn(GLuint fence) { GL_SERVICE_LOG("glIsFenceAPPLE" << "(" << fence << ")"); @@ -13291,6 +13540,13 @@ void LogGLApi::glObjectPtrLabelFn(void* ptr, gl_api_->glObjectPtrLabelFn(ptr, length, label); } +void LogGLApi::glPatchParameteriFn(GLenum pname, GLint value) { + GL_SERVICE_LOG("glPatchParameteri" + << "(" << GLEnums::GetStringEnum(pname) << ", " << value + << ")"); + gl_api_->glPatchParameteriFn(pname, value); +} + void LogGLApi::glPathCommandsNVFn(GLuint path, GLsizei numCommands, const GLubyte* commands, @@ -15324,15 +15580,31 @@ void NoContextGLApi::glBlendEquationFn(GLenum mode) { NoContextHelper("glBlendEquation"); } +void NoContextGLApi::glBlendEquationiOESFn(GLuint buf, GLenum mode) { + NoContextHelper("glBlendEquationiOES"); +} + void NoContextGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) { NoContextHelper("glBlendEquationSeparate"); } +void NoContextGLApi::glBlendEquationSeparateiOESFn(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) { + NoContextHelper("glBlendEquationSeparateiOES"); +} + void NoContextGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) { NoContextHelper("glBlendFunc"); } +void NoContextGLApi::glBlendFunciOESFn(GLuint buf, + GLenum sfactor, + GLenum dfactor) { + NoContextHelper("glBlendFunciOES"); +} + void NoContextGLApi::glBlendFuncSeparateFn(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, @@ -15340,6 +15612,14 @@ void NoContextGLApi::glBlendFuncSeparateFn(GLenum srcRGB, NoContextHelper("glBlendFuncSeparate"); } +void NoContextGLApi::glBlendFuncSeparateiOESFn(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) { + NoContextHelper("glBlendFuncSeparateiOES"); +} + void NoContextGLApi::glBlitFramebufferFn(GLint srcX0, GLint srcY0, GLint srcX1, @@ -15463,6 +15743,14 @@ void NoContextGLApi::glColorMaskFn(GLboolean red, NoContextHelper("glColorMask"); } +void NoContextGLApi::glColorMaskiOESFn(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) { + NoContextHelper("glColorMaskiOES"); +} + void NoContextGLApi::glCompileShaderFn(GLuint shader) { NoContextHelper("glCompileShader"); } @@ -15832,6 +16120,10 @@ void NoContextGLApi::glDisableExtensionANGLEFn(const char* name) { NoContextHelper("glDisableExtensionANGLE"); } +void NoContextGLApi::glDisableiOESFn(GLenum target, GLuint index) { + NoContextHelper("glDisableiOES"); +} + void NoContextGLApi::glDisableVertexAttribArrayFn(GLuint index) { NoContextHelper("glDisableVertexAttribArray"); } @@ -15940,6 +16232,10 @@ void NoContextGLApi::glEnableFn(GLenum cap) { NoContextHelper("glEnable"); } +void NoContextGLApi::glEnableiOESFn(GLenum target, GLuint index) { + NoContextHelper("glEnableiOES"); +} + void NoContextGLApi::glEnableVertexAttribArrayFn(GLuint index) { NoContextHelper("glEnableVertexAttribArray"); } @@ -17002,6 +17298,11 @@ GLboolean NoContextGLApi::glIsEnabledFn(GLenum cap) { return GL_FALSE; } +GLboolean NoContextGLApi::glIsEnablediOESFn(GLenum target, GLuint index) { + NoContextHelper("glIsEnablediOES"); + return GL_FALSE; +} + GLboolean NoContextGLApi::glIsFenceAPPLEFn(GLuint fence) { NoContextHelper("glIsFenceAPPLE"); return GL_FALSE; @@ -17197,6 +17498,10 @@ void NoContextGLApi::glObjectPtrLabelFn(void* ptr, NoContextHelper("glObjectPtrLabel"); } +void NoContextGLApi::glPatchParameteriFn(GLenum pname, GLint value) { + NoContextHelper("glPatchParameteri"); +} + void NoContextGLApi::glPathCommandsNVFn(GLuint path, GLsizei numCommands, const GLubyte* commands, diff --git a/chromium/ui/gl/gl_bindings_autogen_gl.h b/chromium/ui/gl/gl_bindings_autogen_gl.h index 498ba7d718b..76825eda5f4 100644 --- a/chromium/ui/gl/gl_bindings_autogen_gl.h +++ b/chromium/ui/gl/gl_bindings_autogen_gl.h @@ -80,13 +80,26 @@ typedef void(GL_BINDING_CALL* glBlendColorProc)(GLclampf red, GLclampf blue, GLclampf alpha); typedef void(GL_BINDING_CALL* glBlendEquationProc)(GLenum mode); +typedef void(GL_BINDING_CALL* glBlendEquationiOESProc)(GLuint buf, GLenum mode); typedef void(GL_BINDING_CALL* glBlendEquationSeparateProc)(GLenum modeRGB, GLenum modeAlpha); +typedef void(GL_BINDING_CALL* glBlendEquationSeparateiOESProc)( + GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); typedef void(GL_BINDING_CALL* glBlendFuncProc)(GLenum sfactor, GLenum dfactor); +typedef void(GL_BINDING_CALL* glBlendFunciOESProc)(GLuint buf, + GLenum sfactor, + GLenum dfactor); typedef void(GL_BINDING_CALL* glBlendFuncSeparateProc)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +typedef void(GL_BINDING_CALL* glBlendFuncSeparateiOESProc)(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); typedef void(GL_BINDING_CALL* glBlitFramebufferProc)(GLint srcX0, GLint srcY0, GLint srcX1, @@ -153,6 +166,11 @@ typedef void(GL_BINDING_CALL* glColorMaskProc)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +typedef void(GL_BINDING_CALL* glColorMaskiOESProc)(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha); typedef void(GL_BINDING_CALL* glCompileShaderProc)(GLuint shader); typedef void(GL_BINDING_CALL* glCompressedTexImage2DProc)(GLenum target, GLint level, @@ -384,6 +402,7 @@ typedef void(GL_BINDING_CALL* glDetachShaderProc)(GLuint program, GLuint shader); typedef void(GL_BINDING_CALL* glDisableProc)(GLenum cap); typedef void(GL_BINDING_CALL* glDisableExtensionANGLEProc)(const char* name); +typedef void(GL_BINDING_CALL* glDisableiOESProc)(GLenum target, GLuint index); typedef void(GL_BINDING_CALL* glDisableVertexAttribArrayProc)(GLuint index); typedef void(GL_BINDING_CALL* glDiscardFramebufferEXTProc)( GLenum target, @@ -447,6 +466,7 @@ typedef void(GL_BINDING_CALL* glEGLImageTargetTexture2DOESProc)( GLenum target, GLeglImageOES image); typedef void(GL_BINDING_CALL* glEnableProc)(GLenum cap); +typedef void(GL_BINDING_CALL* glEnableiOESProc)(GLenum target, GLuint index); typedef void(GL_BINDING_CALL* glEnableVertexAttribArrayProc)(GLuint index); typedef void(GL_BINDING_CALL* glEndQueryProc)(GLenum target); typedef void(GL_BINDING_CALL* glEndTilingQCOMProc)(GLbitfield preserveMask); @@ -1077,6 +1097,8 @@ typedef void(GL_BINDING_CALL* glInvalidateSubFramebufferProc)( typedef void(GL_BINDING_CALL* glInvalidateTextureANGLEProc)(GLenum target); typedef GLboolean(GL_BINDING_CALL* glIsBufferProc)(GLuint buffer); typedef GLboolean(GL_BINDING_CALL* glIsEnabledProc)(GLenum cap); +typedef GLboolean(GL_BINDING_CALL* glIsEnablediOESProc)(GLenum target, + GLuint index); typedef GLboolean(GL_BINDING_CALL* glIsFenceAPPLEProc)(GLuint fence); typedef GLboolean(GL_BINDING_CALL* glIsFenceNVProc)(GLuint fence); typedef GLboolean(GL_BINDING_CALL* glIsFramebufferEXTProc)(GLuint framebuffer); @@ -1158,6 +1180,7 @@ typedef void(GL_BINDING_CALL* glObjectLabelProc)(GLenum identifier, typedef void(GL_BINDING_CALL* glObjectPtrLabelProc)(void* ptr, GLsizei length, const char* label); +typedef void(GL_BINDING_CALL* glPatchParameteriProc)(GLenum pname, GLint value); typedef void(GL_BINDING_CALL* glPathCommandsNVProc)(GLuint path, GLsizei numCommands, const GLubyte* commands, @@ -2007,6 +2030,7 @@ struct ExtensionsGL { bool b_GL_NV_internalformat_sample_query; bool b_GL_NV_path_rendering; bool b_GL_OES_EGL_image; + bool b_GL_OES_draw_buffers_indexed; bool b_GL_OES_get_program_binary; bool b_GL_OES_mapbuffer; bool b_GL_OES_texture_buffer; @@ -2042,9 +2066,13 @@ struct ProcsGL { glBlendBarrierKHRProc glBlendBarrierKHRFn; glBlendColorProc glBlendColorFn; glBlendEquationProc glBlendEquationFn; + glBlendEquationiOESProc glBlendEquationiOESFn; glBlendEquationSeparateProc glBlendEquationSeparateFn; + glBlendEquationSeparateiOESProc glBlendEquationSeparateiOESFn; glBlendFuncProc glBlendFuncFn; + glBlendFunciOESProc glBlendFunciOESFn; glBlendFuncSeparateProc glBlendFuncSeparateFn; + glBlendFuncSeparateiOESProc glBlendFuncSeparateiOESFn; glBlitFramebufferProc glBlitFramebufferFn; glBufferDataProc glBufferDataFn; glBufferSubDataProc glBufferSubDataFn; @@ -2063,6 +2091,7 @@ struct ProcsGL { glClientWaitSyncProc glClientWaitSyncFn; glClientWaitSyncAPPLEProc glClientWaitSyncAPPLEFn; glColorMaskProc glColorMaskFn; + glColorMaskiOESProc glColorMaskiOESFn; glCompileShaderProc glCompileShaderFn; glCompressedTexImage2DProc glCompressedTexImage2DFn; glCompressedTexImage2DRobustANGLEProc glCompressedTexImage2DRobustANGLEFn; @@ -2118,6 +2147,7 @@ struct ProcsGL { glDetachShaderProc glDetachShaderFn; glDisableProc glDisableFn; glDisableExtensionANGLEProc glDisableExtensionANGLEFn; + glDisableiOESProc glDisableiOESFn; glDisableVertexAttribArrayProc glDisableVertexAttribArrayFn; glDiscardFramebufferEXTProc glDiscardFramebufferEXTFn; glDispatchComputeProc glDispatchComputeFn; @@ -2139,6 +2169,7 @@ struct ProcsGL { glEGLImageTargetRenderbufferStorageOESFn; glEGLImageTargetTexture2DOESProc glEGLImageTargetTexture2DOESFn; glEnableProc glEnableFn; + glEnableiOESProc glEnableiOESFn; glEnableVertexAttribArrayProc glEnableVertexAttribArrayFn; glEndQueryProc glEndQueryFn; glEndTilingQCOMProc glEndTilingQCOMFn; @@ -2307,6 +2338,7 @@ struct ProcsGL { glInvalidateTextureANGLEProc glInvalidateTextureANGLEFn; glIsBufferProc glIsBufferFn; glIsEnabledProc glIsEnabledFn; + glIsEnablediOESProc glIsEnablediOESFn; glIsFenceAPPLEProc glIsFenceAPPLEFn; glIsFenceNVProc glIsFenceNVFn; glIsFramebufferEXTProc glIsFramebufferEXTFn; @@ -2343,6 +2375,7 @@ struct ProcsGL { glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLEFn; glObjectLabelProc glObjectLabelFn; glObjectPtrLabelProc glObjectPtrLabelFn; + glPatchParameteriProc glPatchParameteriFn; glPathCommandsNVProc glPathCommandsNVFn; glPathParameterfNVProc glPathParameterfNVFn; glPathParameteriNVProc glPathParameteriNVFn; @@ -2591,12 +2624,24 @@ class GL_EXPORT GLApi { GLclampf blue, GLclampf alpha) = 0; virtual void glBlendEquationFn(GLenum mode) = 0; + virtual void glBlendEquationiOESFn(GLuint buf, GLenum mode) = 0; virtual void glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) = 0; + virtual void glBlendEquationSeparateiOESFn(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) = 0; virtual void glBlendFuncFn(GLenum sfactor, GLenum dfactor) = 0; + virtual void glBlendFunciOESFn(GLuint buf, + GLenum sfactor, + GLenum dfactor) = 0; virtual void glBlendFuncSeparateFn(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) = 0; + virtual void glBlendFuncSeparateiOESFn(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) = 0; virtual void glBlitFramebufferFn(GLint srcX0, GLint srcY0, GLint srcX1, @@ -2663,6 +2708,11 @@ class GL_EXPORT GLApi { GLboolean green, GLboolean blue, GLboolean alpha) = 0; + virtual void glColorMaskiOESFn(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) = 0; virtual void glCompileShaderFn(GLuint shader) = 0; virtual void glCompressedTexImage2DFn(GLenum target, GLint level, @@ -2864,6 +2914,7 @@ class GL_EXPORT GLApi { virtual void glDetachShaderFn(GLuint program, GLuint shader) = 0; virtual void glDisableFn(GLenum cap) = 0; virtual void glDisableExtensionANGLEFn(const char* name) = 0; + virtual void glDisableiOESFn(GLenum target, GLuint index) = 0; virtual void glDisableVertexAttribArrayFn(GLuint index) = 0; virtual void glDiscardFramebufferEXTFn(GLenum target, GLsizei numAttachments, @@ -2918,6 +2969,7 @@ class GL_EXPORT GLApi { virtual void glEGLImageTargetTexture2DOESFn(GLenum target, GLeglImageOES image) = 0; virtual void glEnableFn(GLenum cap) = 0; + virtual void glEnableiOESFn(GLenum target, GLuint index) = 0; virtual void glEnableVertexAttribArrayFn(GLuint index) = 0; virtual void glEndQueryFn(GLenum target) = 0; virtual void glEndTilingQCOMFn(GLbitfield preserveMask) = 0; @@ -3467,6 +3519,7 @@ class GL_EXPORT GLApi { virtual void glInvalidateTextureANGLEFn(GLenum target) = 0; virtual GLboolean glIsBufferFn(GLuint buffer) = 0; virtual GLboolean glIsEnabledFn(GLenum cap) = 0; + virtual GLboolean glIsEnablediOESFn(GLenum target, GLuint index) = 0; virtual GLboolean glIsFenceAPPLEFn(GLuint fence) = 0; virtual GLboolean glIsFenceNVFn(GLuint fence) = 0; virtual GLboolean glIsFramebufferEXTFn(GLuint framebuffer) = 0; @@ -3542,6 +3595,7 @@ class GL_EXPORT GLApi { virtual void glObjectPtrLabelFn(void* ptr, GLsizei length, const char* label) = 0; + virtual void glPatchParameteriFn(GLenum pname, GLint value) = 0; virtual void glPathCommandsNVFn(GLuint path, GLsizei numCommands, const GLubyte* commands, @@ -4273,10 +4327,16 @@ class GL_EXPORT GLApi { #define glBlendBarrierKHR ::gl::g_current_gl_context->glBlendBarrierKHRFn #define glBlendColor ::gl::g_current_gl_context->glBlendColorFn #define glBlendEquation ::gl::g_current_gl_context->glBlendEquationFn +#define glBlendEquationiOES ::gl::g_current_gl_context->glBlendEquationiOESFn #define glBlendEquationSeparate \ ::gl::g_current_gl_context->glBlendEquationSeparateFn +#define glBlendEquationSeparateiOES \ + ::gl::g_current_gl_context->glBlendEquationSeparateiOESFn #define glBlendFunc ::gl::g_current_gl_context->glBlendFuncFn +#define glBlendFunciOES ::gl::g_current_gl_context->glBlendFunciOESFn #define glBlendFuncSeparate ::gl::g_current_gl_context->glBlendFuncSeparateFn +#define glBlendFuncSeparateiOES \ + ::gl::g_current_gl_context->glBlendFuncSeparateiOESFn #define glBlitFramebuffer ::gl::g_current_gl_context->glBlitFramebufferFn #define glBufferData ::gl::g_current_gl_context->glBufferDataFn #define glBufferSubData ::gl::g_current_gl_context->glBufferSubDataFn @@ -4297,6 +4357,7 @@ class GL_EXPORT GLApi { #define glClientWaitSyncAPPLE \ ::gl::g_current_gl_context->glClientWaitSyncAPPLEFn #define glColorMask ::gl::g_current_gl_context->glColorMaskFn +#define glColorMaskiOES ::gl::g_current_gl_context->glColorMaskiOESFn #define glCompileShader ::gl::g_current_gl_context->glCompileShaderFn #define glCompressedTexImage2D \ ::gl::g_current_gl_context->glCompressedTexImage2DFn @@ -4375,6 +4436,7 @@ class GL_EXPORT GLApi { #define glDisable ::gl::g_current_gl_context->glDisableFn #define glDisableExtensionANGLE \ ::gl::g_current_gl_context->glDisableExtensionANGLEFn +#define glDisableiOES ::gl::g_current_gl_context->glDisableiOESFn #define glDisableVertexAttribArray \ ::gl::g_current_gl_context->glDisableVertexAttribArrayFn #define glDiscardFramebufferEXT \ @@ -4404,6 +4466,7 @@ class GL_EXPORT GLApi { #define glEGLImageTargetTexture2DOES \ ::gl::g_current_gl_context->glEGLImageTargetTexture2DOESFn #define glEnable ::gl::g_current_gl_context->glEnableFn +#define glEnableiOES ::gl::g_current_gl_context->glEnableiOESFn #define glEnableVertexAttribArray \ ::gl::g_current_gl_context->glEnableVertexAttribArrayFn #define glEndQuery ::gl::g_current_gl_context->glEndQueryFn @@ -4659,6 +4722,7 @@ class GL_EXPORT GLApi { ::gl::g_current_gl_context->glInvalidateTextureANGLEFn #define glIsBuffer ::gl::g_current_gl_context->glIsBufferFn #define glIsEnabled ::gl::g_current_gl_context->glIsEnabledFn +#define glIsEnablediOES ::gl::g_current_gl_context->glIsEnablediOESFn #define glIsFenceAPPLE ::gl::g_current_gl_context->glIsFenceAPPLEFn #define glIsFenceNV ::gl::g_current_gl_context->glIsFenceNVFn #define glIsFramebufferEXT ::gl::g_current_gl_context->glIsFramebufferEXTFn @@ -4705,6 +4769,7 @@ class GL_EXPORT GLApi { ->glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLEFn #define glObjectLabel ::gl::g_current_gl_context->glObjectLabelFn #define glObjectPtrLabel ::gl::g_current_gl_context->glObjectPtrLabelFn +#define glPatchParameteri ::gl::g_current_gl_context->glPatchParameteriFn #define glPathCommandsNV ::gl::g_current_gl_context->glPathCommandsNVFn #define glPathParameterfNV ::gl::g_current_gl_context->glPathParameterfNVFn #define glPathParameteriNV ::gl::g_current_gl_context->glPathParameteriNVFn diff --git a/chromium/ui/gl/gl_bindings_autogen_mock.cc b/chromium/ui/gl/gl_bindings_autogen_mock.cc index b712d5c1851..afd8a2a6809 100644 --- a/chromium/ui/gl/gl_bindings_autogen_mock.cc +++ b/chromium/ui/gl/gl_bindings_autogen_mock.cc @@ -10,6 +10,7 @@ #include <string.h> +#include "base/notreached.h" #include "ui/gl/gl_mock.h" namespace { @@ -296,6 +297,34 @@ MockGLInterface::Mock_glBlendEquationSeparate(GLenum modeRGB, interface_->BlendEquationSeparate(modeRGB, modeAlpha); } +void GL_BINDING_CALL +MockGLInterface::Mock_glBlendEquationSeparatei(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) { + MakeGlMockFunctionUnique("glBlendEquationSeparatei"); + interface_->BlendEquationSeparateiOES(buf, modeRGB, modeAlpha); +} + +void GL_BINDING_CALL +MockGLInterface::Mock_glBlendEquationSeparateiOES(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) { + MakeGlMockFunctionUnique("glBlendEquationSeparateiOES"); + interface_->BlendEquationSeparateiOES(buf, modeRGB, modeAlpha); +} + +void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquationi(GLuint buf, + GLenum mode) { + MakeGlMockFunctionUnique("glBlendEquationi"); + interface_->BlendEquationiOES(buf, mode); +} + +void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquationiOES(GLuint buf, + GLenum mode) { + MakeGlMockFunctionUnique("glBlendEquationiOES"); + interface_->BlendEquationiOES(buf, mode); +} + void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunc(GLenum sfactor, GLenum dfactor) { MakeGlMockFunctionUnique("glBlendFunc"); @@ -311,6 +340,40 @@ MockGLInterface::Mock_glBlendFuncSeparate(GLenum srcRGB, interface_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); } +void GL_BINDING_CALL +MockGLInterface::Mock_glBlendFuncSeparatei(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) { + MakeGlMockFunctionUnique("glBlendFuncSeparatei"); + interface_->BlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void GL_BINDING_CALL +MockGLInterface::Mock_glBlendFuncSeparateiOES(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) { + MakeGlMockFunctionUnique("glBlendFuncSeparateiOES"); + interface_->BlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunci(GLuint buf, + GLenum sfactor, + GLenum dfactor) { + MakeGlMockFunctionUnique("glBlendFunci"); + interface_->BlendFunciOES(buf, sfactor, dfactor); +} + +void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunciOES(GLuint buf, + GLenum sfactor, + GLenum dfactor) { + MakeGlMockFunctionUnique("glBlendFunciOES"); + interface_->BlendFunciOES(buf, sfactor, dfactor); +} + void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, @@ -521,6 +584,24 @@ void GL_BINDING_CALL MockGLInterface::Mock_glColorMask(GLboolean red, interface_->ColorMask(red, green, blue, alpha); } +void GL_BINDING_CALL MockGLInterface::Mock_glColorMaski(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) { + MakeGlMockFunctionUnique("glColorMaski"); + interface_->ColorMaskiOES(buf, red, green, blue, alpha); +} + +void GL_BINDING_CALL MockGLInterface::Mock_glColorMaskiOES(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) { + MakeGlMockFunctionUnique("glColorMaskiOES"); + interface_->ColorMaskiOES(buf, red, green, blue, alpha); +} + void GL_BINDING_CALL MockGLInterface::Mock_glCompileShader(GLuint shader) { MakeGlMockFunctionUnique("glCompileShader"); interface_->CompileShader(shader); @@ -1127,6 +1208,18 @@ MockGLInterface::Mock_glDisableVertexAttribArray(GLuint index) { interface_->DisableVertexAttribArray(index); } +void GL_BINDING_CALL MockGLInterface::Mock_glDisablei(GLenum target, + GLuint index) { + MakeGlMockFunctionUnique("glDisablei"); + interface_->DisableiOES(target, index); +} + +void GL_BINDING_CALL MockGLInterface::Mock_glDisableiOES(GLenum target, + GLuint index) { + MakeGlMockFunctionUnique("glDisableiOES"); + interface_->DisableiOES(target, index); +} + void GL_BINDING_CALL MockGLInterface::Mock_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, @@ -1372,6 +1465,18 @@ MockGLInterface::Mock_glEnableVertexAttribArray(GLuint index) { interface_->EnableVertexAttribArray(index); } +void GL_BINDING_CALL MockGLInterface::Mock_glEnablei(GLenum target, + GLuint index) { + MakeGlMockFunctionUnique("glEnablei"); + interface_->EnableiOES(target, index); +} + +void GL_BINDING_CALL MockGLInterface::Mock_glEnableiOES(GLenum target, + GLuint index) { + MakeGlMockFunctionUnique("glEnableiOES"); + interface_->EnableiOES(target, index); +} + void GL_BINDING_CALL MockGLInterface::Mock_glEndQuery(GLenum target) { MakeGlMockFunctionUnique("glEndQuery"); interface_->EndQuery(target); @@ -3014,6 +3119,18 @@ GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnabled(GLenum cap) { return interface_->IsEnabled(cap); } +GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnabledi(GLenum target, + GLuint index) { + MakeGlMockFunctionUnique("glIsEnabledi"); + return interface_->IsEnablediOES(target, index); +} + +GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnablediOES(GLenum target, + GLuint index) { + MakeGlMockFunctionUnique("glIsEnablediOES"); + return interface_->IsEnablediOES(target, index); +} + GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceAPPLE(GLuint fence) { MakeGlMockFunctionUnique("glIsFenceAPPLE"); return interface_->IsFenceAPPLE(fence); @@ -3337,6 +3454,12 @@ MockGLInterface::Mock_glObjectPtrLabelKHR(void* ptr, interface_->ObjectPtrLabel(ptr, length, label); } +void GL_BINDING_CALL MockGLInterface::Mock_glPatchParameteri(GLenum pname, + GLint value) { + MakeGlMockFunctionUnique("glPatchParameteri"); + interface_->PatchParameteri(pname, value); +} + void GL_BINDING_CALL MockGLInterface::Mock_glPathCommandsCHROMIUM(GLuint path, GLsizei numCommands, @@ -5302,10 +5425,29 @@ MockGLInterface::GetGLProcAddress(const char* name) { if (strcmp(name, "glBlendEquationSeparate") == 0) return reinterpret_cast<GLFunctionPointerType>( Mock_glBlendEquationSeparate); + if (strcmp(name, "glBlendEquationSeparatei") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_glBlendEquationSeparatei); + if (strcmp(name, "glBlendEquationSeparateiOES") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_glBlendEquationSeparateiOES); + if (strcmp(name, "glBlendEquationi") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glBlendEquationi); + if (strcmp(name, "glBlendEquationiOES") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glBlendEquationiOES); if (strcmp(name, "glBlendFunc") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glBlendFunc); if (strcmp(name, "glBlendFuncSeparate") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glBlendFuncSeparate); + if (strcmp(name, "glBlendFuncSeparatei") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glBlendFuncSeparatei); + if (strcmp(name, "glBlendFuncSeparateiOES") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_glBlendFuncSeparateiOES); + if (strcmp(name, "glBlendFunci") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glBlendFunci); + if (strcmp(name, "glBlendFunciOES") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glBlendFunciOES); if (strcmp(name, "glBlitFramebuffer") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glBlitFramebuffer); if (strcmp(name, "glBlitFramebufferANGLE") == 0) @@ -5354,6 +5496,10 @@ MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast<GLFunctionPointerType>(Mock_glClientWaitSyncAPPLE); if (strcmp(name, "glColorMask") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glColorMask); + if (strcmp(name, "glColorMaski") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glColorMaski); + if (strcmp(name, "glColorMaskiOES") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glColorMaskiOES); if (strcmp(name, "glCompileShader") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glCompileShader); if (strcmp(name, "glCompressedTexImage2D") == 0) @@ -5519,6 +5665,10 @@ MockGLInterface::GetGLProcAddress(const char* name) { if (strcmp(name, "glDisableVertexAttribArray") == 0) return reinterpret_cast<GLFunctionPointerType>( Mock_glDisableVertexAttribArray); + if (strcmp(name, "glDisablei") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glDisablei); + if (strcmp(name, "glDisableiOES") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glDisableiOES); if (strcmp(name, "glDiscardFramebufferEXT") == 0) return reinterpret_cast<GLFunctionPointerType>( Mock_glDiscardFramebufferEXT); @@ -5591,6 +5741,10 @@ MockGLInterface::GetGLProcAddress(const char* name) { if (strcmp(name, "glEnableVertexAttribArray") == 0) return reinterpret_cast<GLFunctionPointerType>( Mock_glEnableVertexAttribArray); + if (strcmp(name, "glEnablei") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glEnablei); + if (strcmp(name, "glEnableiOES") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glEnableiOES); if (strcmp(name, "glEndQuery") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glEndQuery); if (strcmp(name, "glEndQueryARB") == 0) @@ -6075,6 +6229,10 @@ MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast<GLFunctionPointerType>(Mock_glIsBuffer); if (strcmp(name, "glIsEnabled") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glIsEnabled); + if (strcmp(name, "glIsEnabledi") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glIsEnabledi); + if (strcmp(name, "glIsEnablediOES") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glIsEnablediOES); if (strcmp(name, "glIsFenceAPPLE") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glIsFenceAPPLE); if (strcmp(name, "glIsFenceNV") == 0) @@ -6182,6 +6340,8 @@ MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast<GLFunctionPointerType>(Mock_glObjectPtrLabel); if (strcmp(name, "glObjectPtrLabelKHR") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glObjectPtrLabelKHR); + if (strcmp(name, "glPatchParameteri") == 0) + return reinterpret_cast<GLFunctionPointerType>(Mock_glPatchParameteri); if (strcmp(name, "glPathCommandsCHROMIUM") == 0) return reinterpret_cast<GLFunctionPointerType>(Mock_glPathCommandsCHROMIUM); if (strcmp(name, "glPathCommandsNV") == 0) diff --git a/chromium/ui/gl/gl_bindings_autogen_mock.h b/chromium/ui/gl/gl_bindings_autogen_mock.h index 1387c72f19b..304adb20e58 100644 --- a/chromium/ui/gl/gl_bindings_autogen_mock.h +++ b/chromium/ui/gl/gl_bindings_autogen_mock.h @@ -109,11 +109,35 @@ static void GL_BINDING_CALL Mock_glBlendColor(GLclampf red, static void GL_BINDING_CALL Mock_glBlendEquation(GLenum mode); static void GL_BINDING_CALL Mock_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); +static void GL_BINDING_CALL Mock_glBlendEquationSeparatei(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +static void GL_BINDING_CALL Mock_glBlendEquationSeparateiOES(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +static void GL_BINDING_CALL Mock_glBlendEquationi(GLuint buf, GLenum mode); +static void GL_BINDING_CALL Mock_glBlendEquationiOES(GLuint buf, GLenum mode); static void GL_BINDING_CALL Mock_glBlendFunc(GLenum sfactor, GLenum dfactor); static void GL_BINDING_CALL Mock_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +static void GL_BINDING_CALL Mock_glBlendFuncSeparatei(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); +static void GL_BINDING_CALL Mock_glBlendFuncSeparateiOES(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); +static void GL_BINDING_CALL Mock_glBlendFunci(GLuint buf, + GLenum sfactor, + GLenum dfactor); +static void GL_BINDING_CALL Mock_glBlendFunciOES(GLuint buf, + GLenum sfactor, + GLenum dfactor); static void GL_BINDING_CALL Mock_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, @@ -217,6 +241,16 @@ static void GL_BINDING_CALL Mock_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +static void GL_BINDING_CALL Mock_glColorMaski(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha); +static void GL_BINDING_CALL Mock_glColorMaskiOES(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha); static void GL_BINDING_CALL Mock_glCompileShader(GLuint shader); static void GL_BINDING_CALL Mock_glCompressedTexImage2D(GLenum target, GLint level, @@ -488,6 +522,8 @@ static void GL_BINDING_CALL Mock_glDetachShader(GLuint program, GLuint shader); static void GL_BINDING_CALL Mock_glDisable(GLenum cap); static void GL_BINDING_CALL Mock_glDisableExtensionANGLE(const char* name); static void GL_BINDING_CALL Mock_glDisableVertexAttribArray(GLuint index); +static void GL_BINDING_CALL Mock_glDisablei(GLenum target, GLuint index); +static void GL_BINDING_CALL Mock_glDisableiOES(GLenum target, GLuint index); static void GL_BINDING_CALL Mock_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, @@ -596,6 +632,8 @@ static void GL_BINDING_CALL Mock_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); static void GL_BINDING_CALL Mock_glEnable(GLenum cap); static void GL_BINDING_CALL Mock_glEnableVertexAttribArray(GLuint index); +static void GL_BINDING_CALL Mock_glEnablei(GLenum target, GLuint index); +static void GL_BINDING_CALL Mock_glEnableiOES(GLenum target, GLuint index); static void GL_BINDING_CALL Mock_glEndQuery(GLenum target); static void GL_BINDING_CALL Mock_glEndQueryARB(GLenum target); static void GL_BINDING_CALL Mock_glEndQueryEXT(GLenum target); @@ -1316,6 +1354,9 @@ Mock_glInvalidateSubFramebuffer(GLenum target, static void GL_BINDING_CALL Mock_glInvalidateTextureANGLE(GLenum target); static GLboolean GL_BINDING_CALL Mock_glIsBuffer(GLuint buffer); static GLboolean GL_BINDING_CALL Mock_glIsEnabled(GLenum cap); +static GLboolean GL_BINDING_CALL Mock_glIsEnabledi(GLenum target, GLuint index); +static GLboolean GL_BINDING_CALL Mock_glIsEnablediOES(GLenum target, + GLuint index); static GLboolean GL_BINDING_CALL Mock_glIsFenceAPPLE(GLuint fence); static GLboolean GL_BINDING_CALL Mock_glIsFenceNV(GLuint fence); static GLboolean GL_BINDING_CALL Mock_glIsFramebuffer(GLuint framebuffer); @@ -1420,6 +1461,7 @@ static void GL_BINDING_CALL Mock_glObjectPtrLabel(void* ptr, static void GL_BINDING_CALL Mock_glObjectPtrLabelKHR(void* ptr, GLsizei length, const char* label); +static void GL_BINDING_CALL Mock_glPatchParameteri(GLenum pname, GLint value); static void GL_BINDING_CALL Mock_glPathCommandsCHROMIUM(GLuint path, GLsizei numCommands, const GLubyte* commands, diff --git a/chromium/ui/gl/gl_context.cc b/chromium/ui/gl/gl_context.cc index 94cf06ed56c..60c4665776f 100644 --- a/chromium/ui/gl/gl_context.cc +++ b/chromium/ui/gl/gl_context.cc @@ -201,7 +201,7 @@ void GLContext::DirtyVirtualContextState() { constexpr uint64_t kInvalidFenceId = 0; uint64_t GLContext::BackpressureFenceCreate() { - TRACE_EVENT0("gpu", "GLContextEGL::BackpressureFenceCreate"); + TRACE_EVENT0("gpu", "GLContext::BackpressureFenceCreate"); // This flush will trigger a crash if FlushForDriverCrashWorkaround is not // called sufficiently frequently. @@ -392,6 +392,9 @@ bool GLContext::MakeVirtuallyCurrent( GLContext* virtual_context, GLSurface* surface) { if (!ForceGpuSwitchIfNeeded()) return false; + if (virtual_context_lost_) + return false; + bool switched_real_contexts = GLContext::GetRealCurrent() != this; if (switched_real_contexts || !surface->IsCurrent()) { GLSurface* current_surface = GLSurface::GetCurrent(); @@ -401,6 +404,7 @@ bool GLContext::MakeVirtuallyCurrent( if (switched_real_contexts || !current_surface || !virtual_context->IsCurrent(surface)) { if (!MakeCurrent(surface)) { + virtual_context_lost_ = true; return false; } } @@ -441,6 +445,7 @@ bool GLContext::MakeVirtuallyCurrent( virtual_context->SetCurrent(surface); if (!surface->OnMakeCurrent(virtual_context)) { LOG(ERROR) << "Could not make GLSurface current."; + virtual_context_lost_ = true; return false; } return true; diff --git a/chromium/ui/gl/gl_context.h b/chromium/ui/gl/gl_context.h index 48e9dd36276..a7dd9c470b1 100644 --- a/chromium/ui/gl/gl_context.h +++ b/chromium/ui/gl/gl_context.h @@ -277,6 +277,8 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext>, void DestroyBackpressureFences(); #endif + void MarkVirtualContextLost() { virtual_context_lost_ = true; } + private: friend class base::RefCounted<GLContext>; @@ -309,6 +311,9 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext>, bool state_dirtied_externally_ = false; std::unique_ptr<GLStateRestorer> state_restorer_; std::unique_ptr<GLVersionInfo> version_info_; + // This bit allows us to avoid virtual context state restoration in the case + // where this underlying context becomes lost. https://crbug.com/1061442 + bool virtual_context_lost_ = false; #if defined(OS_MACOSX) std::map<uint64_t, std::unique_ptr<GLFence>> backpressure_fences_; diff --git a/chromium/ui/gl/gl_context_egl.cc b/chromium/ui/gl/gl_context_egl.cc index cbcb9bc6bdd..329fbfbf938 100644 --- a/chromium/ui/gl/gl_context_egl.cc +++ b/chromium/ui/gl/gl_context_egl.cc @@ -269,6 +269,18 @@ YUVToRGBConverter* GLContextEGL::GetYUVToRGBConverter( return yuv_to_rgb_converter.get(); } +void GLContextEGL::SetVisibility(bool visibility) { + if (GLSurfaceEGL::IsANGLEPowerPreferenceSupported()) { + // It doesn't matter whether this context was explicitly allocated + // with a power preference - ANGLE will take care of any default behavior. + if (visibility) { + eglReacquireHighPowerGPUANGLE(display_, context_); + } else { + eglReleaseHighPowerGPUANGLE(display_, context_); + } + } +} + void GLContextEGL::ReleaseYUVToRGBConvertersAndBackpressureFences() { #if defined(OS_MACOSX) bool has_backpressure_fences = HasBackpressureFences(); diff --git a/chromium/ui/gl/gl_context_egl.h b/chromium/ui/gl/gl_context_egl.h index 31945fdd498..ce18596b67d 100644 --- a/chromium/ui/gl/gl_context_egl.h +++ b/chromium/ui/gl/gl_context_egl.h @@ -37,6 +37,7 @@ class GL_EXPORT GLContextEGL : public GLContextReal { void SetUnbindFboOnMakeCurrent() override; YUVToRGBConverter* GetYUVToRGBConverter( const gfx::ColorSpace& color_space) override; + void SetVisibility(bool visibility) override; protected: ~GLContextEGL() override; diff --git a/chromium/ui/gl/gl_context_glx.h b/chromium/ui/gl/gl_context_glx.h index ed203cb607a..47beb46b14c 100644 --- a/chromium/ui/gl/gl_context_glx.h +++ b/chromium/ui/gl/gl_context_glx.h @@ -9,6 +9,7 @@ #include "base/compiler_specific.h" #include "base/macros.h" +#include "ui/gfx/x/x11.h" #include "ui/gfx/x/x11_types.h" #include "ui/gl/gl_context.h" #include "ui/gl/gl_export.h" diff --git a/chromium/ui/gl/gl_context_glx_unittest.cc b/chromium/ui/gl/gl_context_glx_unittest.cc index ce3dedb0f15..5fc733ba5f0 100644 --- a/chromium/ui/gl/gl_context_glx_unittest.cc +++ b/chromium/ui/gl/gl_context_glx_unittest.cc @@ -35,21 +35,19 @@ TEST(GLContextGLXTest, MAYBE_DoNotDestroyOnFailedMakeCurrent) { memset(&swa, 0, sizeof(swa)); swa.background_pixmap = 0; swa.override_redirect = x11::True; - auto xwindow = XCreateWindow(xdisplay, DefaultRootWindow(xdisplay), 0, 0, 10, - 10, // x, y, width, height - 0, // border width - CopyFromParent, // depth - InputOutput, - CopyFromParent, // visual - CWBackPixmap | CWOverrideRedirect, &swa); - XSelectInput(xdisplay, xwindow, StructureNotifyMask); + auto xwindow = static_cast<x11::Window>(XCreateWindow( + xdisplay, DefaultRootWindow(xdisplay), 0, 0, 10, + 10, // x, y, width, height + 0, // border width + static_cast<int>(x11::WindowClass::CopyFromParent), // depth + static_cast<int>(x11::WindowClass::InputOutput), + nullptr, // visual + CWBackPixmap | CWOverrideRedirect, &swa)); - XEvent xevent; - XMapWindow(xdisplay, xwindow); - // Wait until the window is mapped. - while (XNextEvent(xdisplay, &xevent) && xevent.type != MapNotify && - xevent.xmap.window != xwindow) { - } + XMapWindow(xdisplay, static_cast<uint32_t>(xwindow)); + // Since this window is override-redirect, syncing is sufficient + // to ensure the map is complete. + XSync(xdisplay, x11::False); GLImageTestSupport::InitializeGL(base::nullopt); auto surface = @@ -62,12 +60,11 @@ TEST(GLContextGLXTest, MAYBE_DoNotDestroyOnFailedMakeCurrent) { ASSERT_TRUE(context->MakeCurrent(surface.get())); EXPECT_TRUE(context->GetHandle()); - // Destroy the window, and wait until the window is unmapped. There should be - // no x11 errors. context->ReleaseCurrent(surface.get()); - XDestroyWindow(xdisplay, xwindow); - while (XNextEvent(xdisplay, &xevent) && xevent.type != UnmapNotify) { - } + XDestroyWindow(xdisplay, static_cast<uint32_t>(xwindow)); + // Since this window is override-redirect, syncing is sufficient + // to ensure the window is destroyed and unmapped. + XSync(xdisplay, x11::False); ASSERT_FALSE(error_tracker.FoundNewError()); if (context->MakeCurrent(surface.get())) { diff --git a/chromium/ui/gl/gl_features.cc b/chromium/ui/gl/gl_features.cc index a3fcbf5f6dc..b59542f01d1 100644 --- a/chromium/ui/gl/gl_features.cc +++ b/chromium/ui/gl/gl_features.cc @@ -13,7 +13,7 @@ namespace features { // Launched on Windows, still experimental on other platforms. const base::Feature kDefaultPassthroughCommandDecoder{ "DefaultPassthroughCommandDecoder", -#if defined(OS_WIN) +#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(CHROMECAST_BUILD)) base::FEATURE_ENABLED_BY_DEFAULT #else base::FEATURE_DISABLED_BY_DEFAULT diff --git a/chromium/ui/gl/gl_fence_android_native_fence_sync.cc b/chromium/ui/gl/gl_fence_android_native_fence_sync.cc index c59e65ee792..64d1e6e1d07 100644 --- a/chromium/ui/gl/gl_fence_android_native_fence_sync.cc +++ b/chromium/ui/gl/gl_fence_android_native_fence_sync.cc @@ -10,6 +10,7 @@ #include "base/logging.h" #include "base/memory/ptr_util.h" #include "base/time/time.h" +#include "ui/gfx/gpu_fence.h" #include "ui/gfx/gpu_fence_handle.h" #include "ui/gl/gl_surface_egl.h" @@ -77,41 +78,8 @@ base::TimeTicks GLFenceAndroidNativeFenceSync::GetStatusChangeTime() { base::ScopedFD scoped_fd(sync_fd); base::TimeTicks time; - GetStatusChangeTimeForFence(sync_fd, &time); + gfx::GpuFence::GetStatusChangeTime(sync_fd, &time); return time; } -// static -GLFenceAndroidNativeFenceSync::Status -GLFenceAndroidNativeFenceSync::GetStatusChangeTimeForFence( - int fd, - base::TimeTicks* time) { - DCHECK_NE(fd, -1); - - auto info = - std::unique_ptr<sync_fence_info_data, void (*)(sync_fence_info_data*)>{ - sync_fence_info(fd), sync_fence_info_free}; - if (!info) { - LOG(ERROR) << "sync_fence_info returned null for fd : " << fd; - return Status::kInvalid; - } - - const bool signaled = info->status == 1; - if (!signaled) - return Status::kNotSignaled; - - struct sync_pt_info* pt_info = nullptr; - uint64_t timestamp_ns = 0u; - while ((pt_info = sync_pt_info(info.get(), pt_info))) - timestamp_ns = std::max(timestamp_ns, pt_info->timestamp_ns); - - if (timestamp_ns == 0u) { - LOG(ERROR) << "No timestamp provided from sync_pt_info for fd : " << fd; - return Status::kInvalid; - } - - *time = base::TimeTicks() + base::TimeDelta::FromNanoseconds(timestamp_ns); - return Status::kSignaled; -} - } // namespace gl diff --git a/chromium/ui/gl/gl_fence_android_native_fence_sync.h b/chromium/ui/gl/gl_fence_android_native_fence_sync.h index ee083074684..a271beefde3 100644 --- a/chromium/ui/gl/gl_fence_android_native_fence_sync.h +++ b/chromium/ui/gl/gl_fence_android_native_fence_sync.h @@ -28,9 +28,6 @@ class GL_EXPORT GLFenceAndroidNativeFenceSync : public GLFenceEGL { // TimeTicks will be returned in that case. base::TimeTicks GetStatusChangeTime(); - enum Status { kSignaled, kNotSignaled, kInvalid }; - static Status GetStatusChangeTimeForFence(int fd, base::TimeTicks* time); - private: GLFenceAndroidNativeFenceSync(); static std::unique_ptr<GLFenceAndroidNativeFenceSync> CreateInternal( diff --git a/chromium/ui/gl/gl_gl_api_implementation.cc b/chromium/ui/gl/gl_gl_api_implementation.cc index b2f8fbf596d..aa43cde2ffb 100644 --- a/chromium/ui/gl/gl_gl_api_implementation.cc +++ b/chromium/ui/gl/gl_gl_api_implementation.cc @@ -247,9 +247,7 @@ GLApi::GLApi() { GLApi::~GLApi() { } -GLApiBase::GLApiBase() - : driver_(NULL) { -} +GLApiBase::GLApiBase() : driver_(nullptr) {} GLApiBase::~GLApiBase() { } diff --git a/chromium/ui/gl/gl_image_ahardwarebuffer.cc b/chromium/ui/gl/gl_image_ahardwarebuffer.cc index a07f2882f2c..93c0e1aee9c 100644 --- a/chromium/ui/gl/gl_image_ahardwarebuffer.cc +++ b/chromium/ui/gl/gl_image_ahardwarebuffer.cc @@ -61,7 +61,10 @@ class GLImageAHardwareBuffer::ScopedHardwareBufferFenceSyncImpl ScopedHardwareBufferFenceSyncImpl( scoped_refptr<GLImageAHardwareBuffer> image, base::android::ScopedHardwareBufferHandle handle) - : ScopedHardwareBufferFenceSync(std::move(handle), base::ScopedFD()), + : ScopedHardwareBufferFenceSync(std::move(handle), + base::ScopedFD(), + base::ScopedFD(), + false /* is_video */), image_(std::move(image)) {} ~ScopedHardwareBufferFenceSyncImpl() override = default; diff --git a/chromium/ui/gl/gl_image_io_surface_egl.mm b/chromium/ui/gl/gl_image_io_surface_egl.mm index f89f115876e..38ba2029b04 100644 --- a/chromium/ui/gl/gl_image_io_surface_egl.mm +++ b/chromium/ui/gl/gl_image_io_surface_egl.mm @@ -182,8 +182,10 @@ bool GLImageIOSurfaceEGL::BindTexImageImpl(unsigned target, // DrawingBuffer::SetupRGBEmulationForBlitFramebuffer to bind an RGBA // IOSurface as RGB. We should support this. - if (texture_bound_) + if (texture_bound_) { + LOG(ERROR) << "Cannot re-bind already bound IOSurface."; return false; + } GLenum target_getter = TargetGetterFromGLTarget(target); EGLint target_egl = EGLTargetFromGLTarget(target); diff --git a/chromium/ui/gl/gl_image_memory.cc b/chromium/ui/gl/gl_image_memory.cc index 433dae32f13..2a5849f9c82 100644 --- a/chromium/ui/gl/gl_image_memory.cc +++ b/chromium/ui/gl/gl_image_memory.cc @@ -12,7 +12,7 @@ #include "base/numerics/safe_conversions.h" #include "base/synchronization/waitable_event.h" #include "base/system/sys_info.h" -#include "base/task/post_task.h" +#include "base/task/thread_pool.h" #include "base/trace_event/trace_event.h" #include "build/build_config.h" #include "ui/gfx/buffer_format_util.h" @@ -383,8 +383,9 @@ bool GLImageMemory::CopyTexImage(unsigned target) { memcpy_tasks_, base::BindOnce(&base::WaitableEvent::Signal, base::Unretained(&event))); for (int i = 1; i < memcpy_tasks_; ++i) { - base::PostTask(FROM_HERE, base::BindOnce(&MemcpyTask, src, dst, size, i, - memcpy_tasks_, &barrier)); + base::ThreadPool::PostTask( + FROM_HERE, base::BindOnce(&MemcpyTask, src, dst, size, i, + memcpy_tasks_, &barrier)); } MemcpyTask(src, dst, size, 0, memcpy_tasks_, &barrier); event.Wait(); diff --git a/chromium/ui/gl/gl_implementation_wrapper.h b/chromium/ui/gl/gl_implementation_wrapper.h index ce8dd5d204c..d4656b0e7ae 100644 --- a/chromium/ui/gl/gl_implementation_wrapper.h +++ b/chromium/ui/gl/gl_implementation_wrapper.h @@ -8,7 +8,6 @@ #include <memory> #include "base/command_line.h" -#include "base/logging.h" #include "ui/gl/gl_switches.h" #define GL_IMPL_WRAPPER_TYPE(name) \ diff --git a/chromium/ui/gl/gl_mock.h b/chromium/ui/gl/gl_mock.h index 1049ebae2f8..7669731688e 100644 --- a/chromium/ui/gl/gl_mock.h +++ b/chromium/ui/gl/gl_mock.h @@ -9,6 +9,7 @@ #ifndef UI_GL_GL_MOCK_H_ #define UI_GL_GL_MOCK_H_ +#include "base/notreached.h" #include "testing/gmock/include/gmock/gmock.h" #include "ui/gl/gl_bindings.h" diff --git a/chromium/ui/gl/gl_mock_autogen_egl.h b/chromium/ui/gl/gl_mock_autogen_egl.h index ba2f95f308b..07dbdb2d1a6 100644 --- a/chromium/ui/gl/gl_mock_autogen_egl.h +++ b/chromium/ui/gl/gl_mock_autogen_egl.h @@ -149,6 +149,7 @@ MOCK_METHOD5(GetSyncValuesCHROMIUM, EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, EGLuint64CHROMIUM* sbc)); +MOCK_METHOD1(HandleGPUSwitchANGLE, void(EGLDisplay dpy)); MOCK_METHOD3(ImageFlushExternalEXT, EGLBoolean(EGLDisplay dpy, EGLImageKHR image, @@ -210,6 +211,8 @@ MOCK_METHOD4(QuerySurfacePointerANGLE, EGLSurface surface, EGLint attribute, void** value)); +MOCK_METHOD2(ReacquireHighPowerGPUANGLE, void(EGLDisplay dpy, EGLContext ctx)); +MOCK_METHOD2(ReleaseHighPowerGPUANGLE, void(EGLDisplay dpy, EGLContext ctx)); MOCK_METHOD3(ReleaseTexImage, EGLBoolean(EGLDisplay dpy, EGLSurface surface, EGLint buffer)); MOCK_METHOD0(ReleaseThread, EGLBoolean()); diff --git a/chromium/ui/gl/gl_mock_autogen_gl.h b/chromium/ui/gl/gl_mock_autogen_gl.h index 23861cae559..c92ea02d6b7 100644 --- a/chromium/ui/gl/gl_mock_autogen_gl.h +++ b/chromium/ui/gl/gl_mock_autogen_gl.h @@ -58,11 +58,21 @@ MOCK_METHOD0(BlendBarrierKHR, void()); MOCK_METHOD4(BlendColor, void(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)); MOCK_METHOD1(BlendEquation, void(GLenum mode)); +MOCK_METHOD2(BlendEquationiOES, void(GLuint buf, GLenum mode)); MOCK_METHOD2(BlendEquationSeparate, void(GLenum modeRGB, GLenum modeAlpha)); +MOCK_METHOD3(BlendEquationSeparateiOES, + void(GLuint buf, GLenum modeRGB, GLenum modeAlpha)); MOCK_METHOD2(BlendFunc, void(GLenum sfactor, GLenum dfactor)); +MOCK_METHOD3(BlendFunciOES, void(GLuint buf, GLenum sfactor, GLenum dfactor)); MOCK_METHOD4( BlendFuncSeparate, void(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)); +MOCK_METHOD5(BlendFuncSeparateiOES, + void(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha)); MOCK_METHOD10(BlitFramebuffer, void(GLint srcX0, GLint srcY0, @@ -111,6 +121,12 @@ MOCK_METHOD3(ClientWaitSyncAPPLE, MOCK_METHOD4( ColorMask, void(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)); +MOCK_METHOD5(ColorMaskiOES, + void(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha)); MOCK_METHOD1(CompileShader, void(GLuint shader)); MOCK_METHOD8(CompressedTexImage2D, void(GLenum target, @@ -293,6 +309,7 @@ MOCK_METHOD2(DepthRangef, void(GLclampf zNear, GLclampf zFar)); MOCK_METHOD2(DetachShader, void(GLuint program, GLuint shader)); MOCK_METHOD1(Disable, void(GLenum cap)); MOCK_METHOD1(DisableExtensionANGLE, void(const char* name)); +MOCK_METHOD2(DisableiOES, void(GLenum target, GLuint index)); MOCK_METHOD1(DisableVertexAttribArray, void(GLuint index)); MOCK_METHOD3(DiscardFramebufferEXT, void(GLenum target, @@ -344,6 +361,7 @@ MOCK_METHOD2(EGLImageTargetRenderbufferStorageOES, MOCK_METHOD2(EGLImageTargetTexture2DOES, void(GLenum target, GLeglImageOES image)); MOCK_METHOD1(Enable, void(GLenum cap)); +MOCK_METHOD2(EnableiOES, void(GLenum target, GLuint index)); MOCK_METHOD1(EnableVertexAttribArray, void(GLuint index)); MOCK_METHOD1(EndQuery, void(GLenum target)); MOCK_METHOD1(EndTilingQCOM, void(GLbitfield preserveMask)); @@ -900,6 +918,7 @@ MOCK_METHOD7(InvalidateSubFramebuffer, MOCK_METHOD1(InvalidateTextureANGLE, void(GLenum target)); MOCK_METHOD1(IsBuffer, GLboolean(GLuint buffer)); MOCK_METHOD1(IsEnabled, GLboolean(GLenum cap)); +MOCK_METHOD2(IsEnablediOES, GLboolean(GLenum target, GLuint index)); MOCK_METHOD1(IsFenceAPPLE, GLboolean(GLuint fence)); MOCK_METHOD1(IsFenceNV, GLboolean(GLuint fence)); MOCK_METHOD1(IsFramebufferEXT, GLboolean(GLuint framebuffer)); @@ -976,6 +995,7 @@ MOCK_METHOD4( void(GLenum identifier, GLuint name, GLsizei length, const char* label)); MOCK_METHOD3(ObjectPtrLabel, void(void* ptr, GLsizei length, const char* label)); +MOCK_METHOD2(PatchParameteri, void(GLenum pname, GLint value)); MOCK_METHOD6(PathCommandsNV, void(GLuint path, GLsizei numCommands, diff --git a/chromium/ui/gl/gl_share_group.h b/chromium/ui/gl/gl_share_group.h index 3a5c6220418..d3f606d7f4a 100644 --- a/chromium/ui/gl/gl_share_group.h +++ b/chromium/ui/gl/gl_share_group.h @@ -8,7 +8,6 @@ #include <set> #include <unordered_map> -#include "base/logging.h" #include "base/macros.h" #include "base/memory/ref_counted.h" #include "build/build_config.h" diff --git a/chromium/ui/gl/gl_stub_autogen_gl.cc b/chromium/ui/gl/gl_stub_autogen_gl.cc index 3fee2b30af7..95ab0007c78 100644 --- a/chromium/ui/gl/gl_stub_autogen_gl.cc +++ b/chromium/ui/gl/gl_stub_autogen_gl.cc @@ -126,6 +126,10 @@ GLboolean GLStubApiBase::glIsEnabledFn(GLenum cap) { return 0; } +GLboolean GLStubApiBase::glIsEnablediOESFn(GLenum target, GLuint index) { + return 0; +} + GLboolean GLStubApiBase::glIsFenceAPPLEFn(GLuint fence) { return 0; } diff --git a/chromium/ui/gl/gl_stub_autogen_gl.h b/chromium/ui/gl/gl_stub_autogen_gl.h index a175caed59f..7fc5200c4ba 100644 --- a/chromium/ui/gl/gl_stub_autogen_gl.h +++ b/chromium/ui/gl/gl_stub_autogen_gl.h @@ -63,12 +63,22 @@ void glBlendColorFn(GLclampf red, GLclampf blue, GLclampf alpha) override {} void glBlendEquationFn(GLenum mode) override {} +void glBlendEquationiOESFn(GLuint buf, GLenum mode) override {} void glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) override {} +void glBlendEquationSeparateiOESFn(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha) override {} void glBlendFuncFn(GLenum sfactor, GLenum dfactor) override {} +void glBlendFunciOESFn(GLuint buf, GLenum sfactor, GLenum dfactor) override {} void glBlendFuncSeparateFn(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override {} +void glBlendFuncSeparateiOESFn(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha) override {} void glBlitFramebufferFn(GLint srcX0, GLint srcY0, GLint srcX1, @@ -135,6 +145,11 @@ void glColorMaskFn(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override {} +void glColorMaskiOESFn(GLuint buf, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha) override {} void glCompileShaderFn(GLuint shader) override {} void glCompressedTexImage2DFn(GLenum target, GLint level, @@ -334,6 +349,7 @@ void glDepthRangefFn(GLclampf zNear, GLclampf zFar) override {} void glDetachShaderFn(GLuint program, GLuint shader) override {} void glDisableFn(GLenum cap) override {} void glDisableExtensionANGLEFn(const char* name) override {} +void glDisableiOESFn(GLenum target, GLuint index) override {} void glDisableVertexAttribArrayFn(GLuint index) override {} void glDiscardFramebufferEXTFn(GLenum target, GLsizei numAttachments, @@ -386,6 +402,7 @@ void glEGLImageTargetRenderbufferStorageOESFn(GLenum target, void glEGLImageTargetTexture2DOESFn(GLenum target, GLeglImageOES image) override {} void glEnableFn(GLenum cap) override {} +void glEnableiOESFn(GLenum target, GLuint index) override {} void glEnableVertexAttribArrayFn(GLuint index) override {} void glEndQueryFn(GLenum target) override {} void glEndTilingQCOMFn(GLbitfield preserveMask) override {} @@ -921,6 +938,7 @@ void glInvalidateSubFramebufferFn(GLenum target, void glInvalidateTextureANGLEFn(GLenum target) override {} GLboolean glIsBufferFn(GLuint buffer) override; GLboolean glIsEnabledFn(GLenum cap) override; +GLboolean glIsEnablediOESFn(GLenum target, GLuint index) override; GLboolean glIsFenceAPPLEFn(GLuint fence) override; GLboolean glIsFenceNVFn(GLuint fence) override; GLboolean glIsFramebufferEXTFn(GLuint framebuffer) override; @@ -994,6 +1012,7 @@ void glObjectLabelFn(GLenum identifier, const char* label) override {} void glObjectPtrLabelFn(void* ptr, GLsizei length, const char* label) override { } +void glPatchParameteriFn(GLenum pname, GLint value) override {} void glPathCommandsNVFn(GLuint path, GLsizei numCommands, const GLubyte* commands, diff --git a/chromium/ui/gl/gl_surface.h b/chromium/ui/gl/gl_surface.h index b150a76b0d5..44ad2952959 100644 --- a/chromium/ui/gl/gl_surface.h +++ b/chromium/ui/gl/gl_surface.h @@ -131,7 +131,8 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface>, // progress when this callback is invoked, and the signaling of the gpu fence // will mark the completion of the swap operation. using SwapCompletionCallback = - base::OnceCallback<void(gfx::SwapResult, std::unique_ptr<gfx::GpuFence>)>; + base::OnceCallback<void(gfx::SwapCompletionResult)>; + // Swaps front and back buffers. This has no effect for off-screen // contexts. On some platforms, we want to send SwapBufferAck only after the // surface is displayed on screen. The callback can be used to delay sending diff --git a/chromium/ui/gl/gl_surface_egl.cc b/chromium/ui/gl/gl_surface_egl.cc index 07cd11466e3..beda0520c09 100644 --- a/chromium/ui/gl/gl_surface_egl.cc +++ b/chromium/ui/gl/gl_surface_egl.cc @@ -35,6 +35,7 @@ #include "ui/gl/gl_surface_presentation_helper.h" #include "ui/gl/gl_surface_stub.h" #include "ui/gl/gl_utils.h" +#include "ui/gl/gpu_switching_manager.h" #include "ui/gl/scoped_make_current.h" #include "ui/gl/sync_control_vsync_provider.h" @@ -88,6 +89,12 @@ #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_REFERENCE_ANGLE 0x320C #endif /* EGL_ANGLE_platform_angle_d3d */ +#ifndef EGL_ANGLE_platform_angle_d3d_luid +#define EGL_ANGLE_platform_angle_d3d_luid 1 +#define EGL_PLATFORM_ANGLE_D3D_LUID_HIGH_ANGLE 0x34A0 +#define EGL_PLATFORM_ANGLE_D3D_LUID_LOW_ANGLE 0x34A1 +#endif /* EGL_ANGLE_platform_angle_d3d_luid */ + #ifndef EGL_ANGLE_platform_angle_d3d11on12 #define EGL_ANGLE_platform_angle_d3d11on12 1 #define EGL_PLATFORM_ANGLE_D3D11ON12_ANGLE 0x3488 @@ -160,6 +167,8 @@ bool GLSurfaceEGL::initialized_ = false; namespace { +class EGLGpuSwitchingObserver; + EGLDisplay g_egl_display = EGL_NO_DISPLAY; EGLDisplayPlatform g_native_display(EGL_DEFAULT_DISPLAY); @@ -184,6 +193,7 @@ bool g_egl_android_native_fence_sync_supported = false; bool g_egl_ext_pixel_format_float_supported = false; bool g_egl_angle_feature_control_supported = false; bool g_egl_angle_power_preference_supported = false; +EGLGpuSwitchingObserver* g_egl_gpu_switching_observer = nullptr; constexpr const char kSwapEventTraceCategories[] = "gpu"; @@ -248,6 +258,14 @@ class EGLSyncControlVSyncProvider : public SyncControlVSyncProvider { DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider); }; +class EGLGpuSwitchingObserver final : public ui::GpuSwitchingObserver { + public: + void OnGpuSwitched(gl::GpuPreference active_gpu_heuristic) override { + DCHECK(GLSurfaceEGL::IsANGLEPowerPreferenceSupported()); + eglHandleGPUSwitchANGLE(g_egl_display); + } +}; + std::vector<const char*> GetAttribArrayFromStringVector( const std::vector<std::string>& strings) { std::vector<const char*> attribs; @@ -277,6 +295,30 @@ EGLDisplay GetPlatformANGLEDisplay( display_attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE); display_attribs.push_back(static_cast<EGLAttrib>(platform_type)); + if (platform_type == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) { + base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); + if (command_line->HasSwitch(switches::kUseAdapterLuid)) { + // If the LUID is specified, the format is <high part>,<low part>. Split + // and add them to the EGL_ANGLE_platform_angle_d3d_luid ext attributes. + std::string luid = + command_line->GetSwitchValueASCII(switches::kUseAdapterLuid); + size_t comma = luid.find(','); + if (comma != std::string::npos) { + int32_t high; + uint32_t low; + if (!base::StringToInt(luid.substr(0, comma), &high) || + !base::StringToUint(luid.substr(comma + 1), &low)) + return EGL_NO_DISPLAY; + + display_attribs.push_back(EGL_PLATFORM_ANGLE_D3D_LUID_HIGH_ANGLE); + display_attribs.push_back(high); + + display_attribs.push_back(EGL_PLATFORM_ANGLE_D3D_LUID_LOW_ANGLE); + display_attribs.push_back(low); + } + } + } + GLDisplayEglUtil::GetInstance()->GetPlatformExtraDisplayAttribs( platform_type, &display_attribs); @@ -963,6 +1005,12 @@ bool GLSurfaceEGL::InitializeOneOffCommon() { g_egl_angle_power_preference_supported = HasEGLExtension("EGL_ANGLE_power_preference"); + if (g_egl_angle_power_preference_supported) { + g_egl_gpu_switching_observer = new EGLGpuSwitchingObserver(); + ui::GpuSwitchingManager::GetInstance()->AddObserver( + g_egl_gpu_switching_observer); + } + initialized_ = true; return true; } @@ -979,6 +1027,13 @@ bool GLSurfaceEGL::InitializeExtensionSettingsOneOff() { // static void GLSurfaceEGL::ShutdownOneOff() { + if (g_egl_gpu_switching_observer) { + ui::GpuSwitchingManager::GetInstance()->RemoveObserver( + g_egl_gpu_switching_observer); + delete g_egl_gpu_switching_observer; + g_egl_gpu_switching_observer = nullptr; + } + angle::ResetPlatform(g_egl_display); if (g_egl_display != EGL_NO_DISPLAY) { diff --git a/chromium/ui/gl/gl_surface_egl_surface_control.cc b/chromium/ui/gl/gl_surface_egl_surface_control.cc index b07b18a93e6..cf43491e721 100644 --- a/chromium/ui/gl/gl_surface_egl_surface_control.cc +++ b/chromium/ui/gl/gl_surface_egl_surface_control.cc @@ -10,6 +10,7 @@ #include "base/android/build_info.h" #include "base/android/scoped_hardware_buffer_fence_sync.h" #include "base/bind.h" +#include "base/posix/eintr_wrapper.h" #include "base/strings/strcat.h" #include "base/threading/thread_task_runner_handle.h" #include "base/trace_event/trace_event.h" @@ -39,6 +40,18 @@ std::string BuildSurfaceName(const char* suffix) { {base::android::BuildInfo::GetInstance()->package_name(), "/", suffix}); } +base::TimeTicks GetSignalTime(const base::ScopedFD& fence) { + if (!fence.is_valid()) + return base::TimeTicks(); + + base::TimeTicks signal_time; + auto status = gfx::GpuFence::GetStatusChangeTime(fence.get(), &signal_time); + if (status != gfx::GpuFence::kSignaled) + return base::TimeTicks(); + + return signal_time; +} + } // namespace GLSurfaceEGLSurfaceControl::GLSurfaceEGLSurfaceControl( @@ -187,7 +200,8 @@ void GLSurfaceEGLSurfaceControl::CommitPendingTransaction( LOG(ERROR) << "CommitPendingTransaction failed because surface is lost"; surface_lost_ = true; - std::move(completion_callback).Run(gfx::SwapResult::SWAP_FAILED, nullptr); + std::move(completion_callback) + .Run(gfx::SwapCompletionResult(gfx::SwapResult::SWAP_FAILED)); std::move(present_callback).Run(gfx::PresentationFeedback::Failure()); return; } @@ -232,7 +246,9 @@ void GLSurfaceEGLSurfaceControl::CommitPendingTransaction( SurfaceControl::Transaction::OnCompleteCb callback = base::BindOnce( &GLSurfaceEGLSurfaceControl::OnTransactionAckOnGpuThread, weak_factory_.GetWeakPtr(), std::move(completion_callback), - std::move(present_callback), std::move(resources_to_release)); + std::move(present_callback), std::move(resources_to_release), + std::move(primary_plane_fences_)); + primary_plane_fences_.reset(); pending_transaction_->SetOnCompleteCb(std::move(callback), gpu_task_runner_); // Cache only those surfaces which were used in this transaction. The surfaces @@ -299,10 +315,20 @@ bool GLSurfaceEGLSurfaceControl::ScheduleOverlayPlane( AHardwareBuffer* hardware_buffer = nullptr; base::ScopedFD fence_fd; auto scoped_hardware_buffer = image->GetAHardwareBuffer(); + bool is_primary_plane = false; if (scoped_hardware_buffer) { hardware_buffer = scoped_hardware_buffer->buffer(); fence_fd = scoped_hardware_buffer->TakeFence(); + // We currently only promote the display compositor's buffer or a video + // buffer to an overlay. So if this buffer is not for video then it implies + // its the primary plane. + is_primary_plane = !scoped_hardware_buffer->is_video(); + DCHECK(!is_primary_plane || !primary_plane_fences_); + primary_plane_fences_.emplace(); + primary_plane_fences_->available_fence = + scoped_hardware_buffer->TakeAvailableFence(); + auto* a_surface = surface_state.surface->surface(); DCHECK_EQ(pending_frame_resources_.count(a_surface), 0u); @@ -324,6 +350,11 @@ bool GLSurfaceEGLSurfaceControl::ScheduleOverlayPlane( base::ScopedFD(fence_handle.native_fd.fd)); } + if (is_primary_plane) { + primary_plane_fences_->ready_fence = + base::ScopedFD(HANDLE_EINTR(dup(fence_fd.get()))); + } + pending_transaction_->SetBuffer(*surface_state.surface, surface_state.hardware_buffer, std::move(fence_fd)); @@ -411,6 +442,7 @@ void GLSurfaceEGLSurfaceControl::OnTransactionAckOnGpuThread( SwapCompletionCallback completion_callback, PresentationCallback presentation_callback, ResourceRefs released_resources, + base::Optional<PrimaryPlaneFences> primary_plane_fences, SurfaceControl::TransactionStats transaction_stats) { TRACE_EVENT0("gpu", "GLSurfaceEGLSurfaceControl::OnTransactionAckOnGpuThread"); @@ -448,9 +480,15 @@ void GLSurfaceEGLSurfaceControl::OnTransactionAckOnGpuThread( released_resources.clear(); // The presentation feedback callback must run after swap completion. - std::move(completion_callback).Run(gfx::SwapResult::SWAP_ACK, nullptr); + std::move(completion_callback) + .Run(gfx::SwapCompletionResult(gfx::SwapResult::SWAP_ACK)); PendingPresentationCallback pending_cb; + if (primary_plane_fences) { + pending_cb.available_time = + GetSignalTime(primary_plane_fences->available_fence); + pending_cb.ready_time = GetSignalTime(primary_plane_fences->ready_fence); + } pending_cb.latch_time = transaction_stats.latch_time; pending_cb.present_fence = std::move(transaction_stats.present_fence); pending_cb.callback = std::move(presentation_callback); @@ -474,17 +512,16 @@ void GLSurfaceEGLSurfaceControl::CheckPendingPresentationCallbacks() { auto& pending_cb = pending_presentation_callback_queue_.front(); base::TimeTicks signal_time; - auto status = - pending_cb.present_fence.is_valid() - ? GLFenceAndroidNativeFenceSync::GetStatusChangeTimeForFence( - pending_cb.present_fence.get(), &signal_time) - : GLFenceAndroidNativeFenceSync::kInvalid; - if (status == GLFenceAndroidNativeFenceSync::kNotSignaled) + auto status = pending_cb.present_fence.is_valid() + ? gfx::GpuFence::GetStatusChangeTime( + pending_cb.present_fence.get(), &signal_time) + : gfx::GpuFence::kInvalid; + if (status == gfx::GpuFence::kNotSignaled) break; auto flags = gfx::PresentationFeedback::kHWCompletion | gfx::PresentationFeedback::kVSync; - if (status == GLFenceAndroidNativeFenceSync::kInvalid) { + if (status == gfx::GpuFence::kInvalid) { signal_time = pending_cb.latch_time; flags = 0u; } @@ -495,6 +532,10 @@ void GLSurfaceEGLSurfaceControl::CheckPendingPresentationCallbacks() { "presentation_feedback", TRACE_EVENT_SCOPE_THREAD); gfx::PresentationFeedback feedback(signal_time, base::TimeDelta(), flags); + feedback.available_timestamp = pending_cb.available_time; + feedback.ready_timestamp = pending_cb.ready_time; + feedback.latch_timestamp = pending_cb.latch_time; + std::move(pending_cb.callback).Run(feedback); pending_presentation_callback_queue_.pop(); } @@ -591,4 +632,12 @@ GLSurfaceEGLSurfaceControl::PendingPresentationCallback& GLSurfaceEGLSurfaceControl::PendingPresentationCallback::operator=( PendingPresentationCallback&& other) = default; +GLSurfaceEGLSurfaceControl::PrimaryPlaneFences::PrimaryPlaneFences() = default; +GLSurfaceEGLSurfaceControl::PrimaryPlaneFences::~PrimaryPlaneFences() = default; +GLSurfaceEGLSurfaceControl::PrimaryPlaneFences::PrimaryPlaneFences( + PrimaryPlaneFences&& other) = default; +GLSurfaceEGLSurfaceControl::PrimaryPlaneFences& +GLSurfaceEGLSurfaceControl::PrimaryPlaneFences::operator=( + PrimaryPlaneFences&& other) = default; + } // namespace gl diff --git a/chromium/ui/gl/gl_surface_egl_surface_control.h b/chromium/ui/gl/gl_surface_egl_surface_control.h index 425e679e3bd..a82390e3df3 100644 --- a/chromium/ui/gl/gl_surface_egl_surface_control.h +++ b/chromium/ui/gl/gl_surface_egl_surface_control.h @@ -132,11 +132,25 @@ class GL_EXPORT GLSurfaceEGLSurfaceControl : public GLSurfaceEGL { PendingPresentationCallback(PendingPresentationCallback&& other); PendingPresentationCallback& operator=(PendingPresentationCallback&& other); + base::TimeTicks available_time; + base::TimeTicks ready_time; base::TimeTicks latch_time; + base::ScopedFD present_fence; PresentationCallback callback; }; + struct PrimaryPlaneFences { + PrimaryPlaneFences(); + ~PrimaryPlaneFences(); + + PrimaryPlaneFences(PrimaryPlaneFences&& other); + PrimaryPlaneFences& operator=(PrimaryPlaneFences&& other); + + base::ScopedFD available_fence; + base::ScopedFD ready_fence; + }; + void CommitPendingTransaction(const gfx::Rect& damage_rect, SwapCompletionCallback completion_callback, PresentationCallback callback); @@ -147,6 +161,7 @@ class GL_EXPORT GLSurfaceEGLSurfaceControl : public GLSurfaceEGL { SwapCompletionCallback completion_callback, PresentationCallback presentation_callback, ResourceRefs released_resources, + base::Optional<PrimaryPlaneFences> primary_plane_fences, SurfaceControl::TransactionStats transaction_stats); void CheckPendingPresentationCallbacks(); @@ -170,6 +185,10 @@ class GL_EXPORT GLSurfaceEGLSurfaceControl : public GLSurfaceEGL { // transferred to the framework. ResourceRefs pending_frame_resources_; + // The fences associated with the primary plane (renderer by the display + // compositor) for the pending frame. + base::Optional<PrimaryPlaneFences> primary_plane_fences_; + // Transactions waiting to be applied once the previous transaction is acked. std::queue<SurfaceControl::Transaction> pending_transaction_queue_; diff --git a/chromium/ui/gl/gl_surface_egl_x11.cc b/chromium/ui/gl/gl_surface_egl_x11.cc index 2dd6ea790e2..55071e3ff10 100644 --- a/chromium/ui/gl/gl_surface_egl_x11.cc +++ b/chromium/ui/gl/gl_surface_egl_x11.cc @@ -6,6 +6,7 @@ #include "base/threading/thread_task_runner_handle.h" #include "ui/base/x/x11_display_util.h" +#include "ui/gfx/x/randr.h" #include "ui/gfx/x/x11.h" #include "ui/gfx/x/xproto.h" #include "ui/gl/egl_util.h" @@ -17,12 +18,12 @@ namespace { class XrandrIntervalOnlyVSyncProvider : public gfx::VSyncProvider { public: explicit XrandrIntervalOnlyVSyncProvider(Display* display) - : display_(display), interval_(base::TimeDelta::FromSeconds(1 / 60.)) {} + : interval_(base::TimeDelta::FromSeconds(1 / 60.)) {} void GetVSyncParameters(UpdateVSyncCallback callback) override { if (++calls_since_last_update_ >= kCallsBetweenUpdates) { calls_since_last_update_ = 0; - interval_ = ui::GetPrimaryDisplayRefreshIntervalFromXrandr(display_); + interval_ = ui::GetPrimaryDisplayRefreshIntervalFromXrandr(); } base::ThreadTaskRunnerHandle::Get()->PostTask( FROM_HERE, @@ -37,7 +38,6 @@ class XrandrIntervalOnlyVSyncProvider : public gfx::VSyncProvider { bool IsHWClock() const override { return false; } private: - Display* const display_ = nullptr; base::TimeDelta interval_; static const int kCallsBetweenUpdates = 100; int calls_since_last_update_ = kCallsBetweenUpdates; @@ -45,8 +45,8 @@ class XrandrIntervalOnlyVSyncProvider : public gfx::VSyncProvider { } // namespace -NativeViewGLSurfaceEGLX11::NativeViewGLSurfaceEGLX11(EGLNativeWindowType window) - : NativeViewGLSurfaceEGL(window, nullptr) {} +NativeViewGLSurfaceEGLX11::NativeViewGLSurfaceEGLX11(x11::Window window) + : NativeViewGLSurfaceEGL(static_cast<uint32_t>(window), nullptr) {} bool NativeViewGLSurfaceEGLX11::Initialize(GLSurfaceFormat format) { if (!NativeViewGLSurfaceEGL::Initialize(format)) @@ -104,7 +104,8 @@ NativeViewGLSurfaceEGLX11::CreateVsyncProviderInternal() { return std::make_unique<XrandrIntervalOnlyVSyncProvider>(GetXNativeDisplay()); } -bool NativeViewGLSurfaceEGLX11::DispatchXEvent(XEvent* x_event) { +bool NativeViewGLSurfaceEGLX11::DispatchXEvent(x11::Event* x11_event) { + XEvent* x_event = &x11_event->xlib_event(); // When ANGLE is used for EGL, it creates an X11 child window. Expose events // from this window need to be forwarded to this class. bool can_dispatch = diff --git a/chromium/ui/gl/gl_surface_egl_x11.h b/chromium/ui/gl/gl_surface_egl_x11.h index e16ef3f7ff1..01dbe8d332e 100644 --- a/chromium/ui/gl/gl_surface_egl_x11.h +++ b/chromium/ui/gl/gl_surface_egl_x11.h @@ -12,6 +12,7 @@ #include "base/macros.h" #include "ui/events/platform/x11/x11_event_source.h" #include "ui/gfx/x/connection.h" +#include "ui/gfx/x/event.h" #include "ui/gl/gl_export.h" #include "ui/gl/gl_surface_egl.h" @@ -21,7 +22,7 @@ namespace gl { class GL_EXPORT NativeViewGLSurfaceEGLX11 : public NativeViewGLSurfaceEGL, public ui::XEventDispatcher { public: - explicit NativeViewGLSurfaceEGLX11(EGLNativeWindowType window); + explicit NativeViewGLSurfaceEGLX11(x11::Window window); NativeViewGLSurfaceEGLX11(const NativeViewGLSurfaceEGLX11& other) = delete; NativeViewGLSurfaceEGLX11& operator=(const NativeViewGLSurfaceEGLX11& rhs) = delete; @@ -41,7 +42,7 @@ class GL_EXPORT NativeViewGLSurfaceEGLX11 : public NativeViewGLSurfaceEGL, std::unique_ptr<gfx::VSyncProvider> CreateVsyncProviderInternal() override; // XEventDispatcher: - bool DispatchXEvent(XEvent* xev) override; + bool DispatchXEvent(x11::Event* xev) override; std::vector<x11::Window> children_; diff --git a/chromium/ui/gl/gl_surface_egl_x11_gles2.cc b/chromium/ui/gl/gl_surface_egl_x11_gles2.cc index 000b7fd362d..9ddce7c2dff 100644 --- a/chromium/ui/gl/gl_surface_egl_x11_gles2.cc +++ b/chromium/ui/gl/gl_surface_egl_x11_gles2.cc @@ -13,15 +13,16 @@ using ui::X11EventSource; namespace gl { NativeViewGLSurfaceEGLX11GLES2::NativeViewGLSurfaceEGLX11GLES2( - EGLNativeWindowType window) - : NativeViewGLSurfaceEGLX11(0), parent_window_(window) {} + x11::Window window) + : NativeViewGLSurfaceEGLX11(x11::Window::None), parent_window_(window) {} bool NativeViewGLSurfaceEGLX11GLES2::InitializeNativeWindow() { Display* x11_display = GetXNativeDisplay(); XWindowAttributes attributes; - if (!XGetWindowAttributes(x11_display, parent_window_, &attributes)) { - LOG(ERROR) << "XGetWindowAttributes failed for window " << parent_window_ - << "."; + if (!XGetWindowAttributes(x11_display, static_cast<uint32_t>(parent_window_), + &attributes)) { + LOG(ERROR) << "XGetWindowAttributes failed for window " + << static_cast<uint32_t>(parent_window_) << "."; return false; } @@ -35,10 +36,11 @@ bool NativeViewGLSurfaceEGLX11GLES2::InitializeNativeWindow() { memset(&swa, 0, sizeof(swa)); swa.background_pixmap = 0; swa.bit_gravity = NorthWestGravity; - window_ = XCreateWindow(x11_display, parent_window_, 0, 0, size_.width(), - size_.height(), 0, 0 /* CopyFromParent */, - 1 /* InputOutput */, 0 /* CopyFromParent */, - CWBackPixmap | CWBitGravity, &swa); + window_ = XCreateWindow(x11_display, static_cast<uint32_t>(parent_window_), 0, + 0, size_.width(), size_.height(), 0, + static_cast<int>(x11::WindowClass::CopyFromParent), + static_cast<int>(x11::WindowClass::InputOutput), + nullptr, CWBackPixmap | CWBitGravity, &swa); XMapWindow(x11_display, window_); XSelectInput(x11_display, window_, ExposureMask); XFlush(x11_display); @@ -71,16 +73,21 @@ EGLConfig NativeViewGLSurfaceEGLX11GLES2::GetConfig() { // constrain blending precision. const int kBufferSizeOffset = 1; const int kAlphaSizeOffset = 3; - EGLint config_attribs[] = { - EGL_BUFFER_SIZE, ~0, - EGL_ALPHA_SIZE, 8, - EGL_BLUE_SIZE, 8, - EGL_GREEN_SIZE, 8, - EGL_RED_SIZE, 8, - EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, - EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT, - EGL_NONE - }; + EGLint config_attribs[] = {EGL_BUFFER_SIZE, + ~0, + EGL_ALPHA_SIZE, + 8, + EGL_BLUE_SIZE, + 8, + EGL_GREEN_SIZE, + 8, + EGL_RED_SIZE, + 8, + EGL_RENDERABLE_TYPE, + EGL_OPENGL_ES2_BIT, + EGL_SURFACE_TYPE, + EGL_WINDOW_BIT | EGL_PBUFFER_BIT, + EGL_NONE}; config_attribs[kBufferSizeOffset] = win_attribs.depth; EGLDisplay display = GetHardwareDisplay(); @@ -137,14 +144,16 @@ bool NativeViewGLSurfaceEGLX11GLES2::Resize(const gfx::Size& size, return true; } -bool NativeViewGLSurfaceEGLX11GLES2::DispatchXEvent(XEvent* xev) { +bool NativeViewGLSurfaceEGLX11GLES2::DispatchXEvent(x11::Event* x11_event) { + XEvent* xev = &x11_event->xlib_event(); if (xev->type != Expose || xev->xexpose.window != static_cast<Window>(window_)) return false; - xev->xexpose.window = parent_window_; + xev->xexpose.window = static_cast<uint32_t>(parent_window_); Display* x11_display = GetXNativeDisplay(); - XSendEvent(x11_display, parent_window_, x11::False, ExposureMask, xev); + XSendEvent(x11_display, static_cast<uint32_t>(parent_window_), x11::False, + ExposureMask, xev); XFlush(x11_display); return true; } diff --git a/chromium/ui/gl/gl_surface_egl_x11_gles2.h b/chromium/ui/gl/gl_surface_egl_x11_gles2.h index ac4f26c534b..f52ddddb3b9 100644 --- a/chromium/ui/gl/gl_surface_egl_x11_gles2.h +++ b/chromium/ui/gl/gl_surface_egl_x11_gles2.h @@ -10,6 +10,7 @@ #include <string> #include "base/macros.h" +#include "ui/gfx/x/event.h" #include "ui/gl/gl_export.h" #include "ui/gl/gl_surface_egl_x11.h" @@ -19,7 +20,7 @@ namespace gl { class GL_EXPORT NativeViewGLSurfaceEGLX11GLES2 : public NativeViewGLSurfaceEGLX11 { public: - explicit NativeViewGLSurfaceEGLX11GLES2(EGLNativeWindowType window); + explicit NativeViewGLSurfaceEGLX11GLES2(x11::Window window); // NativeViewGLSurfaceEGL overrides. EGLConfig GetConfig() override; @@ -35,9 +36,9 @@ class GL_EXPORT NativeViewGLSurfaceEGLX11GLES2 private: // XEventDispatcher: - bool DispatchXEvent(XEvent* xev) override; + bool DispatchXEvent(x11::Event* xev) override; - EGLNativeWindowType parent_window_; + x11::Window parent_window_; DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceEGLX11GLES2); }; diff --git a/chromium/ui/gl/gl_surface_glx.cc b/chromium/ui/gl/gl_surface_glx.cc index 09a91304794..cbb7513809d 100644 --- a/chromium/ui/gl/gl_surface_glx.cc +++ b/chromium/ui/gl/gl_surface_glx.cc @@ -25,6 +25,7 @@ #include "ui/base/x/x11_display_util.h" #include "ui/base/x/x11_util.h" #include "ui/events/platform/platform_event_source.h" +#include "ui/gfx/native_widget_types.h" #include "ui/gfx/x/x11.h" #include "ui/gfx/x/x11_types.h" #include "ui/gl/gl_bindings.h" @@ -55,12 +56,12 @@ bool g_glx_sgi_video_sync_supported = false; // A 24-bit RGB visual and colormap to use when creating offscreen surfaces. Visual* g_visual = nullptr; -int g_depth = CopyFromParent; -Colormap g_colormap = CopyFromParent; +int g_depth = static_cast<int>(x11::WindowClass::CopyFromParent); +Colormap g_colormap = static_cast<int>(x11::WindowClass::CopyFromParent); GLXFBConfig GetConfigForWindow(Display* display, gfx::AcceleratedWidget window) { - DCHECK(window != 0); + DCHECK(window != gfx::kNullAcceleratedWidget); // This code path is expensive, but we only take it when // attempting to use GLX_ARB_create_context_robustness, in which @@ -75,8 +76,10 @@ GLXFBConfig GetConfigForWindow(Display* display, // it. XWindowAttributes attributes; - if (!XGetWindowAttributes(display, window, &attributes)) { - LOG(ERROR) << "XGetWindowAttributes failed for window " << window << "."; + if (!XGetWindowAttributes(display, static_cast<uint32_t>(window), + &attributes)) { + LOG(ERROR) << "XGetWindowAttributes failed for window " + << static_cast<uint32_t>(window) << "."; return nullptr; } @@ -115,29 +118,31 @@ GLXFBConfig GetConfigForWindow(Display* display, bool CreateDummyWindow(Display* display) { DCHECK(display); - gfx::AcceleratedWidget parent_window = - XRootWindow(display, DefaultScreen(display)); - gfx::AcceleratedWidget window = - XCreateWindow(display, parent_window, 0, 0, 1, 1, 0, CopyFromParent, - InputOutput, CopyFromParent, 0, nullptr); - if (!window) { + auto parent_window = ui::GetX11RootWindow(); + gfx::AcceleratedWidget window = static_cast<gfx::AcceleratedWidget>( + XCreateWindow(display, static_cast<uint32_t>(parent_window), 0, 0, 1, 1, + 0, static_cast<int>(x11::WindowClass::CopyFromParent), + static_cast<int>(x11::WindowClass::InputOutput), nullptr, 0, + nullptr)); + if (window == gfx::kNullAcceleratedWidget) { LOG(ERROR) << "XCreateWindow failed"; return false; } GLXFBConfig config = GetConfigForWindow(display, window); if (!config) { LOG(ERROR) << "Failed to get GLXConfig"; - XDestroyWindow(display, window); + XDestroyWindow(display, static_cast<uint32_t>(window)); return false; } - GLXWindow glx_window = glXCreateWindow(display, config, window, nullptr); + GLXWindow glx_window = + glXCreateWindow(display, config, static_cast<uint32_t>(window), nullptr); if (!glx_window) { LOG(ERROR) << "glXCreateWindow failed"; - XDestroyWindow(display, window); + XDestroyWindow(display, static_cast<uint32_t>(window)); return false; } glXDestroyWindow(display, glx_window); - XDestroyWindow(display, window); + XDestroyWindow(display, static_cast<uint32_t>(window)); return true; } @@ -146,7 +151,7 @@ class OMLSyncControlVSyncProvider : public SyncControlVSyncProvider { explicit OMLSyncControlVSyncProvider(GLXWindow glx_window) : SyncControlVSyncProvider(), glx_window_(glx_window) {} - ~OMLSyncControlVSyncProvider() override {} + ~OMLSyncControlVSyncProvider() override = default; protected: bool GetSyncValues(int64_t* system_time, @@ -249,7 +254,7 @@ class SGIVideoSyncThread : public base::Thread, } static SGIVideoSyncThread* g_video_sync_thread; - GLXContext context_ = 0; + GLXContext context_ = nullptr; THREAD_CHECKER(thread_checker_); @@ -262,7 +267,7 @@ class SGIVideoSyncProviderThreadShim { SGIVideoSyncThread* vsync_thread) : parent_window_(parent_window), vsync_thread_(vsync_thread), - window_(0), + window_(gfx::kNullAcceleratedWidget), glx_window_(0), task_runner_(base::ThreadTaskRunnerHandle::Get()), cancel_vsync_flag_(), @@ -276,8 +281,10 @@ class SGIVideoSyncProviderThreadShim { if (glx_window_) glXDestroyWindow(vsync_thread_->GetDisplay(), glx_window_); - if (window_) - XDestroyWindow(vsync_thread_->GetDisplay(), window_); + if (window_ != gfx::kNullAcceleratedWidget) { + XDestroyWindow(vsync_thread_->GetDisplay(), + static_cast<uint32_t>(window_)); + } } base::AtomicFlag* cancel_vsync_flag() { return &cancel_vsync_flag_; } @@ -287,10 +294,11 @@ class SGIVideoSyncProviderThreadShim { void Initialize() { DCHECK(vsync_thread_->GetDisplay()); - window_ = XCreateWindow(vsync_thread_->GetDisplay(), parent_window_, 0, 0, - 1, 1, 0, CopyFromParent, InputOutput, - CopyFromParent, 0, nullptr); - if (!window_) { + window_ = static_cast<gfx::AcceleratedWidget>(XCreateWindow( + vsync_thread_->GetDisplay(), static_cast<uint32_t>(parent_window_), 0, + 0, 1, 1, 0, static_cast<int>(x11::WindowClass::CopyFromParent), + static_cast<int>(x11::WindowClass::InputOutput), nullptr, 0, nullptr)); + if (window_ == gfx::kNullAcceleratedWidget) { LOG(ERROR) << "video_sync: XCreateWindow failed"; return; } @@ -302,8 +310,8 @@ class SGIVideoSyncProviderThreadShim { return; } - glx_window_ = - glXCreateWindow(vsync_thread_->GetDisplay(), config, window_, nullptr); + glx_window_ = glXCreateWindow(vsync_thread_->GetDisplay(), config, + static_cast<uint32_t>(window_), nullptr); if (!glx_window_) { LOG(ERROR) << "video_sync: glXCreateWindow failed"; return; @@ -319,8 +327,7 @@ class SGIVideoSyncProviderThreadShim { if (!vsync_thread_->GetGLXContext() || cancel_vsync_flag_.IsSet()) return; - base::TimeDelta interval = ui::GetPrimaryDisplayRefreshIntervalFromXrandr( - vsync_thread_->GetDisplay()); + base::TimeDelta interval = ui::GetPrimaryDisplayRefreshIntervalFromXrandr(); glXMakeContextCurrent(vsync_thread_->GetDisplay(), glx_window_, glx_window_, vsync_thread_->GetGLXContext()); @@ -430,7 +437,7 @@ SGIVideoSyncThread* SGIVideoSyncThread::g_video_sync_thread = nullptr; bool GLSurfaceGLX::initialized_ = false; -GLSurfaceGLX::GLSurfaceGLX() {} +GLSurfaceGLX::GLSurfaceGLX() = default; bool GLSurfaceGLX::InitializeOneOff() { if (initialized_) @@ -524,8 +531,8 @@ void GLSurfaceGLX::ShutdownOneOff() { g_glx_sgi_video_sync_supported = false; g_visual = nullptr; - g_depth = CopyFromParent; - g_colormap = CopyFromParent; + g_depth = static_cast<int>(x11::WindowClass::CopyFromParent); + g_colormap = static_cast<int>(x11::WindowClass::CopyFromParent); } // static @@ -597,20 +604,22 @@ void* GLSurfaceGLX::GetDisplay() { return gfx::GetXDisplay(); } -GLSurfaceGLX::~GLSurfaceGLX() {} +GLSurfaceGLX::~GLSurfaceGLX() = default; NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window) : parent_window_(window), - window_(0), + window_(gfx::kNullAcceleratedWidget), glx_window_(0), config_(nullptr), has_swapped_buffers_(false) {} bool NativeViewGLSurfaceGLX::Initialize(GLSurfaceFormat format) { XWindowAttributes attributes; - if (!XGetWindowAttributes(gfx::GetXDisplay(), parent_window_, &attributes)) { - LOG(ERROR) << "XGetWindowAttributes failed for window " << parent_window_ - << "."; + if (!XGetWindowAttributes(gfx::GetXDisplay(), + static_cast<uint32_t>(parent_window_), + &attributes)) { + LOG(ERROR) << "XGetWindowAttributes failed for window " + << static_cast<uint32_t>(parent_window_) << "."; return false; } size_ = gfx::Size(attributes.width, attributes.height); @@ -635,15 +644,16 @@ bool NativeViewGLSurfaceGLX::Initialize(GLSurfaceFormat format) { value_mask |= CWBackPixel; } - window_ = - XCreateWindow(gfx::GetXDisplay(), parent_window_, 0 /* x */, 0 /* y */, - size_.width(), size_.height(), 0 /* border_width */, - g_depth, InputOutput, g_visual, value_mask, &swa); - if (!window_) { + window_ = static_cast<gfx::AcceleratedWidget>(XCreateWindow( + gfx::GetXDisplay(), static_cast<uint32_t>(parent_window_), 0 /* x */, + 0 /* y */, size_.width(), size_.height(), 0 /* border_width */, g_depth, + static_cast<int>(x11::WindowClass::InputOutput), g_visual, value_mask, + &swa)); + if (window_ == gfx::kNullAcceleratedWidget) { LOG(ERROR) << "XCreateWindow failed"; return false; } - XMapWindow(gfx::GetXDisplay(), window_); + XMapWindow(gfx::GetXDisplay(), static_cast<uint32_t>(window_)); RegisterEvents(); XFlush(gfx::GetXDisplay()); @@ -653,7 +663,8 @@ bool NativeViewGLSurfaceGLX::Initialize(GLSurfaceFormat format) { LOG(ERROR) << "Failed to get GLXConfig"; return false; } - glx_window_ = glXCreateWindow(gfx::GetXDisplay(), config_, window_, NULL); + glx_window_ = glXCreateWindow(gfx::GetXDisplay(), config_, + static_cast<uint32_t>(window_), nullptr); if (!glx_window_) { LOG(ERROR) << "glXCreateWindow failed"; return false; @@ -694,10 +705,10 @@ void NativeViewGLSurfaceGLX::Destroy() { glXDestroyWindow(gfx::GetXDisplay(), glx_window_); glx_window_ = 0; } - if (window_) { + if (window_ != gfx::kNullAcceleratedWidget) { UnregisterEvents(); - XDestroyWindow(gfx::GetXDisplay(), window_); - window_ = 0; + XDestroyWindow(gfx::GetXDisplay(), static_cast<uint32_t>(window_)); + window_ = gfx::kNullAcceleratedWidget; XFlush(gfx::GetXDisplay()); } } @@ -708,7 +719,8 @@ bool NativeViewGLSurfaceGLX::Resize(const gfx::Size& size, bool has_alpha) { size_ = size; glXWaitGL(); - XResizeWindow(gfx::GetXDisplay(), window_, size.width(), size.height()); + XResizeWindow(gfx::GetXDisplay(), static_cast<uint32_t>(window_), + size.width(), size.height()); glXWaitX(); return true; } @@ -732,7 +744,8 @@ gfx::SwapResult NativeViewGLSurfaceGLX::SwapBuffers( // XWindow associated to this surface after the first SwapBuffers has // happened, to avoid showing a weird white background while resizing. if (!has_swapped_buffers_) { - XSetWindowBackgroundPixmap(display, parent_window_, 0); + XSetWindowBackgroundPixmap(display, static_cast<uint32_t>(parent_window_), + 0); has_swapped_buffers_ = true; } @@ -802,15 +815,16 @@ NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() { Destroy(); } -void NativeViewGLSurfaceGLX::ForwardExposeEvent(XEvent* event) { - XEvent forwarded_event = *event; - forwarded_event.xexpose.window = parent_window_; - XSendEvent(gfx::GetXDisplay(), parent_window_, x11::False, ExposureMask, - &forwarded_event); +void NativeViewGLSurfaceGLX::ForwardExposeEvent(x11::Event* event) { + XEvent& forwarded_event = event->xlib_event(); + forwarded_event.xexpose.window = static_cast<uint32_t>(parent_window_); + XSendEvent(gfx::GetXDisplay(), static_cast<uint32_t>(parent_window_), + x11::False, ExposureMask, &forwarded_event); XFlush(gfx::GetXDisplay()); } -bool NativeViewGLSurfaceGLX::CanHandleEvent(XEvent* event) { +bool NativeViewGLSurfaceGLX::CanHandleEvent(x11::Event* x11_event) { + XEvent* event = &x11_event->xlib_event(); return event->type == Expose && event->xexpose.window == static_cast<Window>(window_); } @@ -821,24 +835,29 @@ GLXDrawable NativeViewGLSurfaceGLX::GetDrawableHandle() const { UnmappedNativeViewGLSurfaceGLX::UnmappedNativeViewGLSurfaceGLX( const gfx::Size& size) - : size_(size), config_(nullptr), window_(0), glx_window_(0) { + : size_(size), + config_(nullptr), + window_(gfx::kNullAcceleratedWidget), + glx_window_(0) { // Ensure that we don't create a window with zero size. if (size_.GetArea() == 0) size_.SetSize(1, 1); } bool UnmappedNativeViewGLSurfaceGLX::Initialize(GLSurfaceFormat format) { - DCHECK(!window_); + DCHECK_EQ(window_, gfx::kNullAcceleratedWidget); - gfx::AcceleratedWidget parent_window = DefaultRootWindow(gfx::GetXDisplay()); + auto parent_window = ui::GetX11RootWindow(); XSetWindowAttributes attrs; attrs.border_pixel = 0; attrs.colormap = g_colormap; - window_ = XCreateWindow( - gfx::GetXDisplay(), parent_window, 0, 0, size_.width(), size_.height(), 0, - g_depth, InputOutput, g_visual, CWBorderPixel | CWColormap, &attrs); - if (!window_) { + window_ = static_cast<gfx::AcceleratedWidget>( + XCreateWindow(gfx::GetXDisplay(), static_cast<uint32_t>(parent_window), 0, + 0, size_.width(), size_.height(), 0, g_depth, + static_cast<int>(x11::WindowClass::InputOutput), g_visual, + CWBorderPixel | CWColormap, &attrs)); + if (window_ == gfx::kNullAcceleratedWidget) { LOG(ERROR) << "XCreateWindow failed"; return false; } @@ -847,7 +866,8 @@ bool UnmappedNativeViewGLSurfaceGLX::Initialize(GLSurfaceFormat format) { LOG(ERROR) << "Failed to get GLXConfig"; return false; } - glx_window_ = glXCreateWindow(gfx::GetXDisplay(), config_, window_, NULL); + glx_window_ = glXCreateWindow(gfx::GetXDisplay(), config_, + static_cast<uint32_t>(window_), nullptr); if (!glx_window_) { LOG(ERROR) << "glXCreateWindow failed"; return false; @@ -861,9 +881,9 @@ void UnmappedNativeViewGLSurfaceGLX::Destroy() { glXDestroyWindow(gfx::GetXDisplay(), glx_window_); glx_window_ = 0; } - if (window_) { - XDestroyWindow(gfx::GetXDisplay(), window_); - window_ = 0; + if (window_ != gfx::kNullAcceleratedWidget) { + XDestroyWindow(gfx::GetXDisplay(), static_cast<uint32_t>(window_)); + window_ = gfx::kNullAcceleratedWidget; } } diff --git a/chromium/ui/gl/gl_surface_glx.h b/chromium/ui/gl/gl_surface_glx.h index b891b7a3bcc..f09b3455ce0 100644 --- a/chromium/ui/gl/gl_surface_glx.h +++ b/chromium/ui/gl/gl_surface_glx.h @@ -14,6 +14,7 @@ #include "base/macros.h" #include "ui/gfx/geometry/size.h" #include "ui/gfx/native_widget_types.h" +#include "ui/gfx/x/event.h" #include "ui/gfx/x/x11_types.h" #include "ui/gl/gl_export.h" #include "ui/gl/gl_surface.h" @@ -100,10 +101,10 @@ class GL_EXPORT NativeViewGLSurfaceGLX : public GLSurfaceGLX { virtual void UnregisterEvents() = 0; // Forwards Expose event to child window. - void ForwardExposeEvent(XEvent* xevent); + void ForwardExposeEvent(x11::Event* xevent); // Checks if event is Expose for child window. - bool CanHandleEvent(XEvent* xevent); + bool CanHandleEvent(x11::Event* xevent); gfx::AcceleratedWidget window() const { return window_; } diff --git a/chromium/ui/gl/gl_surface_glx_x11.cc b/chromium/ui/gl/gl_surface_glx_x11.cc index 5b45a38660c..8ec86dfc04e 100644 --- a/chromium/ui/gl/gl_surface_glx_x11.cc +++ b/chromium/ui/gl/gl_surface_glx_x11.cc @@ -21,7 +21,8 @@ GLSurfaceGLXX11::~GLSurfaceGLXX11() { void GLSurfaceGLXX11::RegisterEvents() { // Can be null in tests, when we don't care about Exposes. if (X11EventSource::HasInstance()) { - XSelectInput(gfx::GetXDisplay(), window(), ExposureMask); + XSelectInput(gfx::GetXDisplay(), static_cast<uint32_t>(window()), + ExposureMask); X11EventSource::GetInstance()->AddXEventDispatcher(this); } } @@ -31,7 +32,7 @@ void GLSurfaceGLXX11::UnregisterEvents() { X11EventSource::GetInstance()->RemoveXEventDispatcher(this); } -bool GLSurfaceGLXX11::DispatchXEvent(XEvent* event) { +bool GLSurfaceGLXX11::DispatchXEvent(x11::Event* event) { if (!CanHandleEvent(event)) return false; ForwardExposeEvent(event); diff --git a/chromium/ui/gl/gl_surface_glx_x11.h b/chromium/ui/gl/gl_surface_glx_x11.h index 82d09c62777..6b2a4ac5dc8 100644 --- a/chromium/ui/gl/gl_surface_glx_x11.h +++ b/chromium/ui/gl/gl_surface_glx_x11.h @@ -8,6 +8,7 @@ #include "base/macros.h" #include "ui/events/platform/x11/x11_event_source.h" #include "ui/gfx/native_widget_types.h" +#include "ui/gfx/x/event.h" #include "ui/gl/gl_export.h" #include "ui/gl/gl_surface_glx.h" @@ -28,7 +29,7 @@ class GL_EXPORT GLSurfaceGLXX11 : public NativeViewGLSurfaceGLX, void UnregisterEvents() override; // XEventDispatcher: - bool DispatchXEvent(XEvent* event) override; + bool DispatchXEvent(x11::Event* event) override; private: DISALLOW_COPY_AND_ASSIGN(GLSurfaceGLXX11); diff --git a/chromium/ui/gl/gl_surface_overlay.h b/chromium/ui/gl/gl_surface_overlay.h index 4d174ce490f..5b7214f33b2 100644 --- a/chromium/ui/gl/gl_surface_overlay.h +++ b/chromium/ui/gl/gl_surface_overlay.h @@ -42,6 +42,9 @@ class GL_EXPORT GLSurfaceOverlay { void Flush() const; + gfx::GpuFence* gpu_fence() const { return gpu_fence_.get(); } + int z_order() const { return z_order_; } + private: int z_order_; gfx::OverlayTransform transform_; diff --git a/chromium/ui/gl/gl_surface_presentation_helper.cc b/chromium/ui/gl/gl_surface_presentation_helper.cc index 61a745ae80a..0521b51d4ad 100644 --- a/chromium/ui/gl/gl_surface_presentation_helper.cc +++ b/chromium/ui/gl/gl_surface_presentation_helper.cc @@ -7,6 +7,7 @@ #include <utility> #include "base/bind.h" +#include "base/logging.h" #include "base/threading/thread_task_runner_handle.h" #include "build/build_config.h" #include "ui/gfx/vsync_provider.h" diff --git a/chromium/ui/gl/gl_switches.cc b/chromium/ui/gl/gl_switches.cc index c047cd9a82b..f50a1528af6 100644 --- a/chromium/ui/gl/gl_switches.cc +++ b/chromium/ui/gl/gl_switches.cc @@ -141,6 +141,10 @@ const char kEnableDirectCompositionVideoOverlays[] = const char kDisableDirectCompositionVideoOverlays[] = "disable-direct-composition-video-overlays"; +// Initialize the GPU process using the adapter with the specified LUID. This is +// only used on Windows, as LUID is a Windows specific structure. +const char kUseAdapterLuid[] = "use-adapter-luid"; + // This is the list of switches passed from this file that are passed from the // GpuProcessHost to the GPU Process. Add your switch to this list if you need // to read it in the GPU process, else don't add it. @@ -201,6 +205,12 @@ const base::Feature kDirectCompositionPresentationFeedback{ const base::Feature kDirectCompositionSoftwareOverlays{ "DirectCompositionSoftwareOverlays", base::FEATURE_DISABLED_BY_DEFAULT}; +// Allow putting a video swapchain underneath the main swapchain, so overlays +// can be used even if there are controls on top of the video. It can be +// enabled only when overlay is supported. +const base::Feature kDirectCompositionUnderlays{ + "DirectCompositionUnderlays", base::FEATURE_ENABLED_BY_DEFAULT}; + // Use decode swap chain created from compatible video decoder buffers. const base::Feature kDirectCompositionUseNV12DecodeSwapChain{ "DirectCompositionUseNV12DecodeSwapChain", diff --git a/chromium/ui/gl/gl_switches.h b/chromium/ui/gl/gl_switches.h index 05df4c6e069..775c6c702c2 100644 --- a/chromium/ui/gl/gl_switches.h +++ b/chromium/ui/gl/gl_switches.h @@ -69,6 +69,7 @@ GL_EXPORT extern const char kEnableSwapBuffersWithBounds[]; GL_EXPORT extern const char kDisableDirectComposition[]; GL_EXPORT extern const char kEnableDirectCompositionVideoOverlays[]; GL_EXPORT extern const char kDisableDirectCompositionVideoOverlays[]; +GL_EXPORT extern const char kUseAdapterLuid[]; // These flags are used by the test harness code, not passed in by users. GL_EXPORT extern const char kDisableGLDrawingForTests[]; @@ -87,6 +88,7 @@ GL_EXPORT extern const base::Feature kDirectCompositionNonrootOverlays; GL_EXPORT extern const base::Feature kDirectCompositionPreferNV12Overlays; GL_EXPORT extern const base::Feature kDirectCompositionPresentationFeedback; GL_EXPORT extern const base::Feature kDirectCompositionSoftwareOverlays; +GL_EXPORT extern const base::Feature kDirectCompositionUnderlays; GL_EXPORT extern const base::Feature kDirectCompositionUseNV12DecodeSwapChain; GL_EXPORT extern const base::Feature kDefaultANGLEOpenGL; extern const base::Feature kTrackCurrentShaders; diff --git a/chromium/ui/gl/gl_visual_picker_glx.cc b/chromium/ui/gl/gl_visual_picker_glx.cc index d3bd21b11c5..4e836e9be78 100644 --- a/chromium/ui/gl/gl_visual_picker_glx.cc +++ b/chromium/ui/gl/gl_visual_picker_glx.cc @@ -133,9 +133,9 @@ XVisualInfo GLVisualPickerGLX::PickBestRgbaVisual( auto score = [](int c_class) { // A higher score is more preferable. switch (c_class) { - case TrueColor: + case static_cast<int>(x11::VisualClass::TrueColor): return 1; - case DirectColor: + case static_cast<int>(x11::VisualClass::DirectColor): return 0; default: return -1; diff --git a/chromium/ui/gl/init/BUILD.gn b/chromium/ui/gl/init/BUILD.gn index 72a840d78fa..9141ba379fd 100644 --- a/chromium/ui/gl/init/BUILD.gn +++ b/chromium/ui/gl/init/BUILD.gn @@ -56,12 +56,36 @@ jumbo_component("init") { ] libs = [ "OpenGL.framework" ] - } else if (use_x11) { + } else if (use_ozone) { + sources += [ + "gl_display_egl_util_ozone.cc", + "gl_display_egl_util_ozone.h", + "ozone_util.h", + ] + deps += [ "//ui/ozone" ] + } + + # Allow X11 to use Ozone implementation of gl_factory and gl_initializer. + # This is needed temporarily to allow use_x11 && use_ozone build. Once + # use_x11 goes away, this will be removed. Internally, it checks whether + # it should use pure X11 implementation or Ozone implementation based on + # IsUsingOzonePlatform feature flag. + if (use_x11 || use_ozone) { + sources += [ + "gl_factory_ozone.cc", + "gl_initializer_ozone.cc", + ] + deps += [ "//ui/base:features" ] + } + + if (use_x11) { sources += [ "gl_display_egl_util_x11.cc", "gl_display_egl_util_x11.h", - "gl_factory_x11.cc", - "gl_initializer_x11.cc", + "gl_factory_linux_x11.cc", + "gl_factory_linux_x11.h", + "gl_initializer_linux_x11.cc", + "gl_initializer_linux_x11.h", ] deps += [ @@ -69,15 +93,5 @@ jumbo_component("init") { "//ui/base/x:gl", "//ui/gfx/x", ] - } else if (use_ozone) { - sources += [ - "gl_display_egl_util_ozone.cc", - "gl_display_egl_util_ozone.h", - "gl_factory_ozone.cc", - "gl_initializer_ozone.cc", - "ozone_util.h", - ] - - deps += [ "//ui/ozone" ] } } diff --git a/chromium/ui/gl/init/DEPS b/chromium/ui/gl/init/DEPS index 6b2bc9584ad..82a1175c23c 100644 --- a/chromium/ui/gl/init/DEPS +++ b/chromium/ui/gl/init/DEPS @@ -1,4 +1,5 @@ include_rules = [ + "+ui/base/ui_base_features.h", "+ui/ozone/gl", "+ui/ozone/public", ] diff --git a/chromium/ui/gl/init/create_gr_gl_interface.cc b/chromium/ui/gl/init/create_gr_gl_interface.cc index d71dd24f871..cb283629719 100644 --- a/chromium/ui/gl/init/create_gr_gl_interface.cc +++ b/chromium/ui/gl/init/create_gr_gl_interface.cc @@ -426,6 +426,7 @@ sk_sp<GrGLInterface> CreateGrGLInterface( // functions->fMultiDrawArraysIndirect = gl->glMultiDrawArraysIndirectFn; // functions->fMultiDrawElementsIndirect = gl->glMultiDrawElementsIndirectFn; + functions->fPatchParameteri = gl->glPatchParameteriFn; functions->fPixelStorei = gl->glPixelStoreiFn; functions->fPolygonMode = gl->glPolygonModeFn; functions->fProgramBinary = gl->glProgramBinaryFn; diff --git a/chromium/ui/gl/init/gl_factory_x11.cc b/chromium/ui/gl/init/gl_factory_linux_x11.cc index 4bebef1a31d..ed722461046 100644 --- a/chromium/ui/gl/init/gl_factory_x11.cc +++ b/chromium/ui/gl/init/gl_factory_linux_x11.cc @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "ui/gl/init/gl_factory.h" +#include "ui/gl/init/gl_factory_linux_x11.h" #include "base/trace_event/trace_event.h" #include "ui/gl/gl_context.h" @@ -23,7 +23,7 @@ namespace gl { namespace init { -std::vector<GLImplementation> GetAllowedGLImplementations() { +std::vector<GLImplementation> GetAllowedGLImplementationsX11() { std::vector<GLImplementation> impls; impls.push_back(kGLImplementationDesktopGL); impls.push_back(kGLImplementationEGLGLES2); @@ -32,8 +32,8 @@ std::vector<GLImplementation> GetAllowedGLImplementations() { return impls; } -bool GetGLWindowSystemBindingInfo(const GLVersionInfo& gl_info, - GLWindowSystemBindingInfo* info) { +bool GetGLWindowSystemBindingInfoX11(const GLVersionInfo& gl_info, + GLWindowSystemBindingInfo* info) { switch (GetGLImplementation()) { case kGLImplementationDesktopGL: return GetGLWindowSystemBindingInfoGLX(gl_info, info); @@ -45,9 +45,9 @@ bool GetGLWindowSystemBindingInfo(const GLVersionInfo& gl_info, } } -scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group, - GLSurface* compatible_surface, - const GLContextAttribs& attribs) { +scoped_refptr<GLContext> CreateGLContextX11(GLShareGroup* share_group, + GLSurface* compatible_surface, + const GLContextAttribs& attribs) { TRACE_EVENT0("gpu", "gl::init::CreateGLContext"); switch (GetGLImplementation()) { case kGLImplementationDesktopGL: @@ -72,7 +72,7 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group, } } -scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) { +scoped_refptr<GLSurface> CreateViewGLSurfaceX11(gfx::AcceleratedWidget window) { TRACE_EVENT0("gpu", "gl::init::CreateViewGLSurface"); switch (GetGLImplementation()) { case kGLImplementationDesktopGL: @@ -93,8 +93,9 @@ scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) { } } -scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat( - const gfx::Size& size, GLSurfaceFormat format) { +scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormatX11( + const gfx::Size& size, + GLSurfaceFormat format) { TRACE_EVENT0("gpu", "gl::init::CreateOffscreenGLSurface"); switch (GetGLImplementation()) { case kGLImplementationDesktopGL: @@ -119,7 +120,7 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat( } } -void SetDisabledExtensionsPlatform(const std::string& disabled_extensions) { +void SetDisabledExtensionsPlatformX11(const std::string& disabled_extensions) { GLImplementation implementation = GetGLImplementation(); DCHECK_NE(kGLImplementationNone, implementation); switch (implementation) { @@ -139,7 +140,7 @@ void SetDisabledExtensionsPlatform(const std::string& disabled_extensions) { } } -bool InitializeExtensionSettingsOneOffPlatform() { +bool InitializeExtensionSettingsOneOffPlatformX11() { GLImplementation implementation = GetGLImplementation(); DCHECK_NE(kGLImplementationNone, implementation); switch (implementation) { diff --git a/chromium/ui/gl/init/gl_factory_linux_x11.h b/chromium/ui/gl/init/gl_factory_linux_x11.h new file mode 100644 index 00000000000..ce6519ef58b --- /dev/null +++ b/chromium/ui/gl/init/gl_factory_linux_x11.h @@ -0,0 +1,98 @@ +// Copyright 2020 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. + +#ifndef UI_GL_INIT_GL_FACTORY_LINUX_X11_H_ +#define UI_GL_INIT_GL_FACTORY_LINUX_X11_H_ + +#include <memory> +#include <string> +#include <vector> + +#include "base/memory/ref_counted.h" +#include "ui/gfx/geometry/size.h" +#include "ui/gfx/native_widget_types.h" +#include "ui/gl/gl_implementation.h" +#include "ui/gl/gl_surface_format.h" +#include "ui/gl/gpu_preference.h" + +namespace gl { + +class GLContext; +class GLShareGroup; +class GLSurface; + +struct GLContextAttribs; +struct GLVersionInfo; + +// Note that this is a temporary implementation for Linux/X11 GL. It is called +// through GLFactoryOzone, and will be removed as soon as Linux/Ozone is +// the default. Comments have been copied from gl_factory.h +// +// TODO(msisov): remove this once Ozone is the default on Linux. +namespace init { + +// Returns a list of allowed GL implementations. The default implementation will +// be the first item. +std::vector<GLImplementation> GetAllowedGLImplementationsX11(); + +// Initializes GL bindings and extension settings. +bool InitializeGLOneOffX11(); + +// Initializes GL bindings without initializing extension settings. +bool InitializeGLNoExtensionsOneOffX11(bool init_bindings); + +// Initializes GL bindings - load dlls and get proc address according to gl +// command line switch. +bool InitializeStaticGLBindingsOneOffX11(); + +// Initialize plaiform dependent extension settings, including bindings, +// capabilities, etc. +bool InitializeExtensionSettingsOneOffPlatformX11(); + +// Initializes GL bindings using the provided parameters. This might be required +// for use in tests. +bool InitializeStaticGLBindingsImplementationX11(GLImplementation impl, + bool fallback_to_software_gl); + +// Initializes GL platform using the provided parameters. This might be required +// for use in tests. This should be called only after GL bindings are initilzed +// successfully. +bool InitializeGLOneOffPlatformImplementationX11(bool fallback_to_software_gl, + bool disable_gl_drawing, + bool init_extensions); + +// Clears GL bindings and resets GL implementation. +void ShutdownGLX11(bool due_to_fallback); + +// Return information about the GL window system binding implementation (e.g., +// EGL, GLX, WGL). Returns true if the information was retrieved successfully. +bool GetGLWindowSystemBindingInfoX11(const GLVersionInfo& gl_info, + GLWindowSystemBindingInfo* info); + +// Creates a GL context that is compatible with the given surface. +// |share_group|, if non-null, is a group of contexts which the internally +// created OpenGL context shares textures and other resources. +scoped_refptr<GLContext> CreateGLContextX11(GLShareGroup* share_group, + GLSurface* compatible_surface, + const GLContextAttribs& attribs); + +// Creates a GL surface that renders directly to a view. +scoped_refptr<GLSurface> CreateViewGLSurfaceX11(gfx::AcceleratedWidget window); + +// Creates a GL surface used for offscreen rendering. +scoped_refptr<GLSurface> CreateOffscreenGLSurfaceX11(const gfx::Size& size); + +scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormatX11( + const gfx::Size& size, + GLSurfaceFormat format); + +// Set platform dependent disabled extensions and re-initialize extension +// bindings. +void SetDisabledExtensionsPlatformX11(const std::string& disabled_extensions); + +} // namespace init + +} // namespace gl + +#endif // UI_GL_INIT_GL_FACTORY_LINUX_X11_H_ diff --git a/chromium/ui/gl/init/gl_factory_ozone.cc b/chromium/ui/gl/init/gl_factory_ozone.cc index cd64372831f..a53de798086 100644 --- a/chromium/ui/gl/init/gl_factory_ozone.cc +++ b/chromium/ui/gl/init/gl_factory_ozone.cc @@ -14,20 +14,45 @@ #include "ui/gl/gl_share_group.h" #include "ui/gl/gl_surface.h" #include "ui/gl/gl_surface_stub.h" + +#if defined(USE_OZONE) #include "ui/gl/init/ozone_util.h" +#endif + +#if defined(USE_X11) +#include "ui/base/ui_base_features.h" +#include "ui/gl/init/gl_factory_linux_x11.h" +#endif namespace gl { namespace init { std::vector<GLImplementation> GetAllowedGLImplementations() { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::GetAllowedGLImplementationsX11(); +#endif + +#if defined(USE_OZONE) DCHECK(GetSurfaceFactoryOzone()); return GetSurfaceFactoryOzone()->GetAllowedGLImplementations(); +#else + NOTREACHED(); + return {}; +#endif } bool GetGLWindowSystemBindingInfo(const GLVersionInfo& gl_info, GLWindowSystemBindingInfo* info) { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::GetGLWindowSystemBindingInfoX11(gl_info, info); +#endif + +#if defined(USE_OZONE) if (HasGLOzone()) return GetGLOzone()->GetGLWindowSystemBindingInfo(gl_info, info); +#endif return false; } @@ -35,6 +60,13 @@ bool GetGLWindowSystemBindingInfo(const GLVersionInfo& gl_info, scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group, GLSurface* compatible_surface, const GLContextAttribs& attribs) { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::CreateGLContextX11(share_group, compatible_surface, + attribs); +#endif + +#if defined(USE_OZONE) TRACE_EVENT0("gpu", "gl::init::CreateGLContext"); if (HasGLOzone()) { @@ -56,10 +88,18 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group, default: NOTREACHED() << "Expected Mock or Stub, actual:" << GetGLImplementation(); } +#endif + return nullptr; } scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::CreateViewGLSurfaceX11(window); +#endif + +#if defined(USE_OZONE) TRACE_EVENT0("gpu", "gl::init::CreateViewGLSurface"); if (HasGLOzone()) @@ -72,22 +112,37 @@ scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) { default: NOTREACHED() << "Expected Mock or Stub, actual:" << GetGLImplementation(); } +#endif return nullptr; } scoped_refptr<GLSurface> CreateSurfacelessViewGLSurface( gfx::AcceleratedWidget window) { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) { + return nullptr; + } +#endif + +#if defined(USE_OZONE) TRACE_EVENT0("gpu", "gl::init::CreateSurfacelessViewGLSurface"); if (HasGLOzone()) return GetGLOzone()->CreateSurfacelessViewGLSurface(window); +#endif return nullptr; } scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat( const gfx::Size& size, GLSurfaceFormat format) { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::CreateOffscreenGLSurfaceWithFormatX11(size, format); +#endif + +#if defined(USE_OZONE) TRACE_EVENT0("gpu", "gl::init::CreateOffscreenGLSurface"); if (!format.IsCompatible(GLSurfaceFormat())) { @@ -105,11 +160,20 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat( default: NOTREACHED() << "Expected Mock or Stub, actual:" << GetGLImplementation(); } +#endif return nullptr; } void SetDisabledExtensionsPlatform(const std::string& disabled_extensions) { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) { + gl::init::SetDisabledExtensionsPlatformX11(disabled_extensions); + return; + } +#endif + +#if defined(USE_OZONE) if (HasGLOzone()) { GetGLOzone()->SetDisabledExtensionsPlatform(disabled_extensions); return; @@ -122,9 +186,16 @@ void SetDisabledExtensionsPlatform(const std::string& disabled_extensions) { default: NOTREACHED() << "Expected Mock or Stub, actual:" << GetGLImplementation(); } +#endif } bool InitializeExtensionSettingsOneOffPlatform() { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::InitializeExtensionSettingsOneOffPlatformX11(); +#endif + +#if defined(USE_OZONE) if (HasGLOzone()) return GetGLOzone()->InitializeExtensionSettingsOneOffPlatform(); @@ -136,6 +207,8 @@ bool InitializeExtensionSettingsOneOffPlatform() { NOTREACHED() << "Expected Mock or Stub, actual:" << GetGLImplementation(); return false; } +#endif + return false; } } // namespace init diff --git a/chromium/ui/gl/init/gl_initializer_x11.cc b/chromium/ui/gl/init/gl_initializer_linux_x11.cc index d76d146b0d8..0c57d500c0d 100644 --- a/chromium/ui/gl/init/gl_initializer_x11.cc +++ b/chromium/ui/gl/init/gl_initializer_linux_x11.cc @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "ui/gl/init/gl_initializer.h" +#include "ui/gl/init/gl_initializer_linux_x11.h" #include "base/command_line.h" #include "base/logging.h" @@ -45,7 +45,7 @@ const char kEGLSwiftShaderLibraryName[] = "libEGL.so"; #endif bool InitializeStaticGLXInternal() { - base::NativeLibrary library = NULL; + base::NativeLibrary library = nullptr; const base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); @@ -142,7 +142,7 @@ bool InitializeStaticEGLInternal(GLImplementation implementation) { } // namespace -bool InitializeGLOneOffPlatform() { +bool InitializeGLOneOffPlatformX11() { switch (GetGLImplementation()) { case kGLImplementationDesktopGL: if (!GLSurfaceGLX::InitializeOneOff()) { @@ -155,8 +155,8 @@ bool InitializeGLOneOffPlatform() { case kGLImplementationEGLANGLE: // Set utility class that helps to initialize egl platform. gl::GLDisplayEglUtil::SetInstance(gl::GLDisplayEglUtilX11::GetInstance()); - if (!GLSurfaceEGL::InitializeOneOff( - EGLDisplayPlatform(gfx::GetXDisplay()))) { + if (!GLSurfaceEGL::InitializeOneOff(EGLDisplayPlatform( + reinterpret_cast<EGLNativeDisplayType>(gfx::GetXDisplay())))) { LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed."; return false; } @@ -166,7 +166,7 @@ bool InitializeGLOneOffPlatform() { } } -bool InitializeStaticGLBindings(GLImplementation implementation) { +bool InitializeStaticGLBindingsX11(GLImplementation implementation) { // Prevent reinitialization with a different implementation. Once the gpu // unit tests have initialized with kGLImplementationMock, we don't want to // later switch to another GL implementation. @@ -197,7 +197,7 @@ bool InitializeStaticGLBindings(GLImplementation implementation) { return false; } -void ShutdownGLPlatform() { +void ShutdownGLPlatformX11() { GLSurfaceEGL::ShutdownOneOff(); GLSurfaceGLX::ShutdownOneOff(); ClearBindingsEGL(); diff --git a/chromium/ui/gl/init/gl_initializer_linux_x11.h b/chromium/ui/gl/init/gl_initializer_linux_x11.h new file mode 100644 index 00000000000..07e0f8654de --- /dev/null +++ b/chromium/ui/gl/init/gl_initializer_linux_x11.h @@ -0,0 +1,38 @@ +// Copyright 2020 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. + +#ifndef UI_GL_INIT_GL_INITIALIZER_LINUX_X11_H_ +#define UI_GL_INIT_GL_INITIALIZER_LINUX_X11_H_ + +#include "ui/gl/gl_implementation.h" + +namespace gl { + +// Note that this is a temporary gl implementation for Linux/X11 GL. It is +// called through GLFactoryOzone, and will be removed as soon as Linux/Ozone is +// default. +// +// TODO(msisov): remove this once Ozone is default on Linux. +namespace init { + +// Performs platform dependent one-off GL initialization, calling into the +// appropriate GLSurface code to initialize it. To perform one-off GL +// initialization you should use InitializeGLOneOff() or +// InitializeStaticGLBindingsOneOff() + +// InitializeGLNoExtensionsOneOff(). For tests possibly +// InitializeStaticGLBindingsImplementation() + +// InitializeGLOneOffPlatformImplementation() instead. +bool InitializeGLOneOffPlatformX11(); + +// Initializes a particular GL implementation. +bool InitializeStaticGLBindingsX11(GLImplementation implementation); + +// Clears GL bindings for all implementations supported by platform. +void ShutdownGLPlatformX11(); + +} // namespace init + +} // namespace gl + +#endif // UI_GL_INIT_GL_INITIALIZER_LINUX_X11_H_ diff --git a/chromium/ui/gl/init/gl_initializer_mac.cc b/chromium/ui/gl/init/gl_initializer_mac.cc index 0deebafe135..d8ad42a0755 100644 --- a/chromium/ui/gl/init/gl_initializer_mac.cc +++ b/chromium/ui/gl/init/gl_initializer_mac.cc @@ -226,6 +226,7 @@ bool InitializeStaticGLBindings(GLImplementation implementation) { void ShutdownGLPlatform() { ClearBindingsGL(); #if defined(USE_EGL) + GLSurfaceEGL::ShutdownOneOff(); ClearBindingsEGL(); #endif // defined(USE_EGL) } diff --git a/chromium/ui/gl/init/gl_initializer_ozone.cc b/chromium/ui/gl/init/gl_initializer_ozone.cc index a94b6d4b7cb..aac4833f6c9 100644 --- a/chromium/ui/gl/init/gl_initializer_ozone.cc +++ b/chromium/ui/gl/init/gl_initializer_ozone.cc @@ -9,14 +9,28 @@ #include "ui/gl/gl_bindings.h" #include "ui/gl/gl_gl_api_implementation.h" #include "ui/gl/gl_surface.h" + +#if defined(USE_OZONE) #include "ui/gl/init/gl_display_egl_util_ozone.h" #include "ui/gl/init/ozone_util.h" #include "ui/ozone/public/ozone_platform.h" +#endif + +#if defined(USE_X11) +#include "ui/base/ui_base_features.h" +#include "ui/gl/init/gl_initializer_linux_x11.h" +#endif namespace gl { namespace init { bool InitializeGLOneOffPlatform() { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::InitializeGLOneOffPlatformX11(); +#endif + +#if defined(USE_OZONE) if (HasGLOzone()) { gl::GLDisplayEglUtil::SetInstance(gl::GLDisplayEglUtilOzone::GetInstance()); return GetGLOzone()->InitializeGLOneOffPlatform(); @@ -29,10 +43,17 @@ bool InitializeGLOneOffPlatform() { default: NOTREACHED(); } +#endif return false; } bool InitializeStaticGLBindings(GLImplementation implementation) { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::InitializeStaticGLBindingsX11(implementation); +#endif + +#if defined(USE_OZONE) // Prevent reinitialization with a different implementation. Once the gpu // unit tests have initialized with kGLImplementationMock, we don't want to // later switch to another GL implementation. @@ -52,17 +73,25 @@ bool InitializeStaticGLBindings(GLImplementation implementation) { default: NOTREACHED(); } +#endif return false; } void ShutdownGLPlatform() { +#if defined(USE_X11) + if (!features::IsUsingOzonePlatform()) + return gl::init::ShutdownGLPlatformX11(); +#endif + +#if defined(USE_OZONE) if (HasGLOzone()) { GetGLOzone()->ShutdownGL(); return; } ClearBindingsGL(); +#endif } } // namespace init diff --git a/chromium/ui/gl/scoped_binders.cc b/chromium/ui/gl/scoped_binders.cc index f44272e878e..9375094bb01 100644 --- a/chromium/ui/gl/scoped_binders.cc +++ b/chromium/ui/gl/scoped_binders.cc @@ -11,7 +11,7 @@ namespace gl { ScopedFramebufferBinder::ScopedFramebufferBinder(unsigned int fbo) : state_restorer_(!GLContext::GetCurrent() - ? NULL + ? nullptr : GLContext::GetCurrent()->GetGLStateRestorer()), old_fbo_(-1) { if (!state_restorer_) @@ -31,7 +31,7 @@ ScopedFramebufferBinder::~ScopedFramebufferBinder() { ScopedActiveTexture::ScopedActiveTexture(unsigned int texture) : state_restorer_(!GLContext::GetCurrent() - ? NULL + ? nullptr : GLContext::GetCurrent()->GetGLStateRestorer()), old_texture_(-1) { if (!state_restorer_) @@ -51,7 +51,7 @@ ScopedActiveTexture::~ScopedActiveTexture() { ScopedTextureBinder::ScopedTextureBinder(unsigned int target, unsigned int id) : state_restorer_(!GLContext::GetCurrent() - ? NULL + ? nullptr : GLContext::GetCurrent()->GetGLStateRestorer()), target_(target), old_id_(-1) { @@ -90,7 +90,7 @@ ScopedTextureBinder::~ScopedTextureBinder() { ScopedUseProgram::ScopedUseProgram(unsigned int program) : state_restorer_(!GLContext::GetCurrent() - ? NULL + ? nullptr : GLContext::GetCurrent()->GetGLStateRestorer()), old_program_(-1) { if (!state_restorer_) @@ -115,7 +115,7 @@ ScopedVertexAttribArray::ScopedVertexAttribArray(unsigned int index, int stride, const void* pointer) : state_restorer_(!GLContext::GetCurrent() - ? NULL + ? nullptr : GLContext::GetCurrent()->GetGLStateRestorer()), buffer_(0), enabled_(GL_FALSE), @@ -124,7 +124,7 @@ ScopedVertexAttribArray::ScopedVertexAttribArray(unsigned int index, type_(-1), normalized_(GL_FALSE), stride_(0), - pointer_(0) { + pointer_(nullptr) { if (!state_restorer_) { glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &buffer_); glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &enabled_); @@ -154,7 +154,7 @@ ScopedVertexAttribArray::~ScopedVertexAttribArray() { ScopedBufferBinder::ScopedBufferBinder(unsigned int target, unsigned int id) : state_restorer_(!GLContext::GetCurrent() - ? NULL + ? nullptr : GLContext::GetCurrent()->GetGLStateRestorer()), target_(target), old_id_(-1) { diff --git a/chromium/ui/gl/scoped_cgl.cc b/chromium/ui/gl/scoped_cgl.cc index db7a62e2185..6be02ab3afc 100644 --- a/chromium/ui/gl/scoped_cgl.cc +++ b/chromium/ui/gl/scoped_cgl.cc @@ -3,6 +3,9 @@ // found in the LICENSE file. #include "ui/gl/scoped_cgl.h" + +#include <ostream> + #include "base/check_op.h" namespace gl { diff --git a/chromium/ui/gl/swap_chain_presenter.cc b/chromium/ui/gl/swap_chain_presenter.cc index 40851d765bd..d5ba73d26a3 100644 --- a/chromium/ui/gl/swap_chain_presenter.cc +++ b/chromium/ui/gl/swap_chain_presenter.cc @@ -259,9 +259,12 @@ Microsoft::WRL::ComPtr<ID3D11Texture2D> SwapChainPresenter::UploadVideoImages( copy_texture_.Reset(); HRESULT hr = d3d11_device_->CreateTexture2D(&desc, nullptr, &staging_texture_); + base::UmaHistogramSparse( + "GPU.DirectComposition.UploadVideoImages.CreateStagingTexture", hr); if (FAILED(hr)) { DLOG(ERROR) << "Creating D3D11 video staging texture failed: " << std::hex << hr; + DirectCompositionSurfaceWin::DisableOverlays(); return nullptr; } DCHECK(staging_texture_); @@ -311,9 +314,12 @@ Microsoft::WRL::ComPtr<ID3D11Texture2D> SwapChainPresenter::UploadVideoImages( desc.BindFlags = D3D11_BIND_DECODER; desc.CPUAccessFlags = 0; HRESULT hr = d3d11_device_->CreateTexture2D(&desc, nullptr, ©_texture_); + base::UmaHistogramSparse( + "GPU.DirectComposition.UploadVideoImages.CreateCopyTexture", hr); if (FAILED(hr)) { DLOG(ERROR) << "Creating D3D11 video upload texture failed: " << std::hex << hr; + DirectCompositionSurfaceWin::DisableOverlays(); return nullptr; } DCHECK(copy_texture_); @@ -587,7 +593,11 @@ bool SwapChainPresenter::PresentToDecodeSwapChain( DCHECK(media_factory); DXGI_DECODE_SWAP_CHAIN_DESC desc = {}; - desc.Flags = 0; + // Set the DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO flag to mark this surface + // as a candidate for full screen video optimizations. If the surface + // does not qualify as fullscreen by DWM's logic then the flag will have + // no effects. + desc.Flags = DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO; HRESULT hr = media_factory->CreateDecodeSwapChainForCompositionSurfaceHandle( d3d11_device_.Get(), swap_chain_handle_.Get(), &desc, @@ -606,8 +616,8 @@ bool SwapChainPresenter::PresentToDecodeSwapChain( dcomp_device_.As(&desktop_device); DCHECK(desktop_device); - desktop_device->CreateSurfaceFromHandle(swap_chain_handle_.Get(), - &decode_surface_); + hr = desktop_device->CreateSurfaceFromHandle(swap_chain_handle_.Get(), + &decode_surface_); if (FAILED(hr)) { DLOG(ERROR) << "CreateSurfaceFromHandle failed with error 0x" << std::hex << hr; diff --git a/chromium/ui/gl/vsync_thread_win.cc b/chromium/ui/gl/vsync_thread_win.cc index 9502606f05d..ec027e3339d 100644 --- a/chromium/ui/gl/vsync_thread_win.cc +++ b/chromium/ui/gl/vsync_thread_win.cc @@ -5,6 +5,7 @@ #include "ui/gl/vsync_thread_win.h" #include "base/bind.h" +#include "base/logging.h" #include "base/memory/singleton.h" #include "base/stl_util.h" #include "ui/gl/gl_angle_util_win.h" @@ -54,6 +55,7 @@ VSyncThreadWin* VSyncThreadWin::GetInstance() { VSyncThreadWin::VSyncThreadWin() : vsync_thread_("GpuVSyncThread"), + vsync_provider_(gfx::kNullAcceleratedWidget), d3d11_device_(QueryD3D11DeviceObjectFromANGLE()) { DCHECK(d3d11_device_); base::Thread::Options options; @@ -86,32 +88,23 @@ void VSyncThreadWin::RemoveObserver(VSyncObserver* obs) { } void VSyncThreadWin::WaitForVSync() { + base::TimeTicks vsync_phase; + base::TimeDelta vsync_interval; + const bool get_vsync_params_succeeded = + vsync_provider_.GetVSyncParametersIfAvailable(&vsync_phase, + &vsync_interval); + DCHECK(get_vsync_params_succeeded); + // From Raymond Chen's blog "How do I get a handle to the primary monitor?" // https://devblogs.microsoft.com/oldnewthing/20141106-00/?p=43683 - HMONITOR monitor = MonitorFromWindow(nullptr, MONITOR_DEFAULTTOPRIMARY); + const HMONITOR monitor = MonitorFromWindow(nullptr, MONITOR_DEFAULTTOPRIMARY); if (primary_monitor_ != monitor) { primary_monitor_ = monitor; primary_output_ = DXGIOutputFromMonitor(monitor, d3d11_device_); } - base::TimeDelta interval = base::TimeDelta::FromSecondsD(1.0 / 60); - - MONITORINFOEX monitor_info = {}; - monitor_info.cbSize = sizeof(MONITORINFOEX); - if (monitor && GetMonitorInfo(monitor, &monitor_info)) { - DEVMODE display_info = {}; - display_info.dmSize = sizeof(DEVMODE); - display_info.dmDriverExtra = 0; - if (EnumDisplaySettings(monitor_info.szDevice, ENUM_CURRENT_SETTINGS, - &display_info) && - display_info.dmDisplayFrequency > 1) { - interval = - base::TimeDelta::FromSecondsD(1.0 / display_info.dmDisplayFrequency); - } - } - - base::TimeTicks wait_for_vblank_start_time = base::TimeTicks::Now(); - bool wait_for_vblank_succeeded = + const base::TimeTicks wait_for_vblank_start_time = base::TimeTicks::Now(); + const bool wait_for_vblank_succeeded = primary_output_ && SUCCEEDED(primary_output_->WaitForVBlank()); // WaitForVBlank returns very early instead of waiting until vblank when the @@ -119,13 +112,13 @@ void VSyncThreadWin::WaitForVSync() { // WaitForVBlank and fallback to Sleep() if it returns before that. This // could happen during normal operation for the first call after the vsync // thread becomes non-idle, but it shouldn't happen often. - const auto kVBlankIntervalThreshold = base::TimeDelta::FromMilliseconds(1); - base::TimeDelta wait_for_vblank_elapsed_time = + constexpr auto kVBlankIntervalThreshold = + base::TimeDelta::FromMilliseconds(1); + const base::TimeDelta wait_for_vblank_elapsed_time = base::TimeTicks::Now() - wait_for_vblank_start_time; - if (!wait_for_vblank_succeeded || wait_for_vblank_elapsed_time < kVBlankIntervalThreshold) { - Sleep(static_cast<DWORD>(interval.InMillisecondsRoundedUp())); + Sleep(static_cast<DWORD>(vsync_interval.InMillisecondsRoundedUp())); } base::AutoLock auto_lock(lock_); @@ -133,9 +126,9 @@ void VSyncThreadWin::WaitForVSync() { vsync_thread_.task_runner()->PostTask( FROM_HERE, base::BindOnce(&VSyncThreadWin::WaitForVSync, base::Unretained(this))); - base::TimeTicks vsync_time = base::TimeTicks::Now(); + const base::TimeTicks vsync_time = base::TimeTicks::Now(); for (auto* obs : observers_) - obs->OnVSync(vsync_time, interval); + obs->OnVSync(vsync_time, vsync_interval); } else { is_idle_ = true; } diff --git a/chromium/ui/gl/vsync_thread_win.h b/chromium/ui/gl/vsync_thread_win.h index d148353ddc3..e3d65f122c2 100644 --- a/chromium/ui/gl/vsync_thread_win.h +++ b/chromium/ui/gl/vsync_thread_win.h @@ -12,6 +12,7 @@ #include "base/containers/flat_set.h" #include "base/threading/thread.h" #include "ui/gl/gl_export.h" +#include "ui/gl/vsync_provider_win.h" namespace base { template <typename T> @@ -46,6 +47,7 @@ class GL_EXPORT VSyncThreadWin { base::Thread vsync_thread_; // Used on vsync thread only after initialization. + VSyncProviderWin vsync_provider_; const Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device_; HMONITOR primary_monitor_ = nullptr; Microsoft::WRL::ComPtr<IDXGIOutput> primary_output_; diff --git a/chromium/ui/gl/yuv_to_rgb_converter.cc b/chromium/ui/gl/yuv_to_rgb_converter.cc index 5e2c4e23e2a..e76c9410523 100644 --- a/chromium/ui/gl/yuv_to_rgb_converter.cc +++ b/chromium/ui/gl/yuv_to_rgb_converter.cc @@ -4,6 +4,7 @@ #include "ui/gl/yuv_to_rgb_converter.h" +#include "base/notreached.h" #include "base/strings/stringize_macros.h" #include "base/strings/stringprintf.h" #include "ui/gfx/color_transform.h" @@ -119,7 +120,7 @@ STRINGIZE( } // namespace YUVToRGBConverter::YUVToRGBConverter(const GLVersionInfo& gl_version_info, - const gfx::ColorSpace color_space) { + const gfx::ColorSpace& color_space) { std::unique_ptr<gfx::ColorTransform> color_transform = gfx::ColorTransform::NewColorTransform( color_space, color_space.GetAsFullRangeRGB(), diff --git a/chromium/ui/gl/yuv_to_rgb_converter.h b/chromium/ui/gl/yuv_to_rgb_converter.h index 3c8178db823..d228de30e59 100644 --- a/chromium/ui/gl/yuv_to_rgb_converter.h +++ b/chromium/ui/gl/yuv_to_rgb_converter.h @@ -18,7 +18,7 @@ struct GLVersionInfo; class YUVToRGBConverter { public: explicit YUVToRGBConverter(const GLVersionInfo& gl_version_info, - const gfx::ColorSpace color_space); + const gfx::ColorSpace& color_space); ~YUVToRGBConverter(); // The input Y and UV textures should be bound to these texture objects |