1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gpu/ipc/service/image_transport_surface.h"
#include <android/native_window_jni.h>
#include <utility>
#include <variant>
#include "base/android/jni_android.h"
#include "base/android/scoped_java_ref.h"
#include "base/feature_list.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/task/single_thread_task_runner.h"
#include "gpu/config/gpu_feature_info.h"
#include "gpu/ipc/common/gpu_surface_lookup.h"
#include "third_party/abseil-cpp/absl/functional/overload.h"
#include "ui/gl/android/scoped_a_native_window.h"
#include "ui/gl/gl_surface_egl.h"
#include "ui/gl/gl_surface_egl_surface_control.h"
#include "ui/gl/gl_surface_stub.h"
namespace gpu {
// static
scoped_refptr<gl::Presenter> ImageTransportSurface::CreatePresenter(
scoped_refptr<SharedContextState> context_state,
const GpuDriverBugWorkarounds& workarounds,
const GpuFeatureInfo& gpu_feature_info,
SurfaceHandle surface_handle) {
if (gl::GetGLImplementation() == gl::kGLImplementationMockGL ||
gl::GetGLImplementation() == gl::kGLImplementationStubGL)
return nullptr;
if (gpu_feature_info
.status_values[GPU_FEATURE_TYPE_ANDROID_SURFACE_CONTROL] !=
gpu::kGpuFeatureStatusEnabled) {
return nullptr;
}
DCHECK(GpuSurfaceLookup::GetInstance());
DCHECK_NE(surface_handle, kNullSurfaceHandle);
// On Android, the surface_handle is the id of the surface in the
// GpuSurfaceTracker/GpuSurfaceLookup
auto surface_record =
GpuSurfaceLookup::GetInstance()->AcquireJavaSurface(surface_handle);
if (!surface_record.can_be_used_with_surface_control) {
return nullptr;
}
scoped_refptr<gl::Presenter> presenter;
std::visit(
absl::Overload{[&](gl::ScopedJavaSurface&& scoped_java_surface) {
gl::ScopedANativeWindow window(scoped_java_surface);
if (!window) {
LOG(WARNING) << "Failed to acquire ANativeWindow";
return;
}
presenter = new gl::GLSurfaceEGLSurfaceControl(
std::move(window),
base::SingleThreadTaskRunner::GetCurrentDefault());
},
[&](gl::ScopedJavaSurfaceControl&& surface_control) {
presenter = new gl::GLSurfaceEGLSurfaceControl(
std::move(surface_control),
base::SingleThreadTaskRunner::GetCurrentDefault());
}},
std::move(surface_record.surface_variant));
return presenter;
}
// static
scoped_refptr<gl::GLSurface> ImageTransportSurface::CreateNativeGLSurface(
gl::GLDisplay* display,
SurfaceHandle surface_handle,
gl::GLSurfaceFormat format) {
if (gl::GetGLImplementation() == gl::kGLImplementationMockGL ||
gl::GetGLImplementation() == gl::kGLImplementationStubGL) {
return base::MakeRefCounted<gl::GLSurfaceStub>();
}
// For some unittests, we will using ANGLE with Null ANGLE backend, in this
// case, we need to use SurfacelessEGL.
if (gl::GetGLImplementation() == gl::kGLImplementationEGLANGLE &&
gl::GetANGLEImplementation() == gl::ANGLEImplementation::kNull) {
auto surface = base::MakeRefCounted<gl::SurfacelessEGL>(
display->GetAs<gl::GLDisplayEGL>(), gfx::Size());
if (!surface->Initialize(format)) {
return nullptr;
}
return surface;
}
DCHECK(GpuSurfaceLookup::GetInstance());
DCHECK_NE(surface_handle, kNullSurfaceHandle);
// On Android, the surface_handle is the id of the surface in the
// GpuSurfaceTracker/GpuSurfaceLookup
auto surface_record =
GpuSurfaceLookup::GetInstance()->AcquireJavaSurface(surface_handle);
if (!std::holds_alternative<gl::ScopedJavaSurface>(
surface_record.surface_variant)) {
LOG(WARNING) << "Expected Java Surface";
return nullptr;
}
gl::ScopedJavaSurface& scoped_java_surface =
std::get<gl::ScopedJavaSurface>(surface_record.surface_variant);
gl::ScopedANativeWindow window(scoped_java_surface);
if (!window) {
LOG(WARNING) << "Failed to acquire ANativeWindow";
return nullptr;
}
scoped_refptr<gl::GLSurface> surface = new gl::NativeViewGLSurfaceEGL(
display->GetAs<gl::GLDisplayEGL>(), std::move(window), nullptr);
bool initialize_success = surface->Initialize(format);
if (!initialize_success)
return scoped_refptr<gl::GLSurface>();
return surface;
}
} // namespace gpu
|
