Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(999)

Side by Side Diff: content/browser/renderer_host/render_widget_host_view_android.cc

Issue 2336043004: Android: Free GLHelper context ashmem when it makes sense (Closed)
Patch Set: address comments Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "content/browser/renderer_host/render_widget_host_view_android.h" 5 #include "content/browser/renderer_host/render_widget_host_view_android.h"
6 6
7 #include <android/bitmap.h> 7 #include <android/bitmap.h>
8 8
9 #include <utility> 9 #include <utility>
10 10
11 #include "base/android/application_status_listener.h"
11 #include "base/android/build_info.h" 12 #include "base/android/build_info.h"
12 #include "base/android/context_utils.h" 13 #include "base/android/context_utils.h"
13 #include "base/bind.h" 14 #include "base/bind.h"
14 #include "base/callback_helpers.h" 15 #include "base/callback_helpers.h"
15 #include "base/command_line.h" 16 #include "base/command_line.h"
16 #include "base/location.h" 17 #include "base/location.h"
17 #include "base/logging.h" 18 #include "base/logging.h"
18 #include "base/macros.h" 19 #include "base/macros.h"
20 #include "base/memory/memory_pressure_listener.h"
19 #include "base/metrics/histogram_macros.h" 21 #include "base/metrics/histogram_macros.h"
20 #include "base/single_thread_task_runner.h" 22 #include "base/single_thread_task_runner.h"
21 #include "base/strings/utf_string_conversions.h" 23 #include "base/strings/utf_string_conversions.h"
22 #include "base/sys_info.h" 24 #include "base/sys_info.h"
23 #include "base/threading/thread_task_runner_handle.h" 25 #include "base/threading/thread_task_runner_handle.h"
24 #include "base/threading/worker_pool.h" 26 #include "base/threading/worker_pool.h"
25 #include "cc/layers/layer.h" 27 #include "cc/layers/layer.h"
26 #include "cc/layers/surface_layer.h" 28 #include "cc/layers/surface_layer.h"
27 #include "cc/output/compositor_frame.h" 29 #include "cc/output/compositor_frame.h"
28 #include "cc/output/copy_output_request.h" 30 #include "cc/output/copy_output_request.h"
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
93 #include "ui/touch_selection/touch_selection_controller.h" 95 #include "ui/touch_selection/touch_selection_controller.h"
94 96
95 namespace content { 97 namespace content {
96 98
97 namespace { 99 namespace {
98 100
99 const int kUndefinedCompositorFrameSinkId = -1; 101 const int kUndefinedCompositorFrameSinkId = -1;
100 102
101 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime"; 103 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
102 104
105 using base::android::ApplicationState;
106 using base::android::ApplicationStatusListener;
107 using base::MemoryPressureListener;
108
103 class GLHelperHolder { 109 class GLHelperHolder {
104 public: 110 public:
105 static GLHelperHolder* Create(); 111 static GLHelperHolder* Create();
106 112
107 display_compositor::GLHelper* gl_helper() { return gl_helper_.get(); } 113 display_compositor::GLHelper* gl_helper() { return gl_helper_.get(); }
108 bool IsLost() { 114 bool IsLost() {
109 if (!gl_helper_) 115 if (!gl_helper_)
110 return true; 116 return true;
111 return provider_->ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR; 117 return provider_->ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
112 } 118 }
113 119
120 void FreeUnusedSharedMemoryIfNeeded();
121
114 private: 122 private:
115 GLHelperHolder() = default; 123 GLHelperHolder();
116 void Initialize(); 124 void Initialize();
117 void OnContextLost(); 125 void OnContextLost();
126 void OnApplicationStatusChanged(ApplicationState new_state);
127 void OnMemoryPressure(MemoryPressureListener::MemoryPressureLevel level);
118 128
119 scoped_refptr<ContextProviderCommandBuffer> provider_; 129 scoped_refptr<ContextProviderCommandBuffer> provider_;
120 std::unique_ptr<display_compositor::GLHelper> gl_helper_; 130 std::unique_ptr<display_compositor::GLHelper> gl_helper_;
121 131
132 // Set to |false| if there are only stopped activities (or none).
133 bool has_running_or_paused_activities_;
134 // Whether we recently were signaled a low memory condition.
135 bool did_signal_memory_pressure_;
136
137 std::unique_ptr<ApplicationStatusListener> app_status_listener_;
138 std::unique_ptr<MemoryPressureListener> mem_pressure_listener_;
139
122 DISALLOW_COPY_AND_ASSIGN(GLHelperHolder); 140 DISALLOW_COPY_AND_ASSIGN(GLHelperHolder);
123 }; 141 };
124 142
143 GLHelperHolder::GLHelperHolder()
144 : has_running_or_paused_activities_(
145 (ApplicationStatusListener::GetState() ==
146 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES) ||
147 (ApplicationStatusListener::GetState() ==
148 base::android::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES)),
149 did_signal_memory_pressure_(false) {}
150
125 GLHelperHolder* GLHelperHolder::Create() { 151 GLHelperHolder* GLHelperHolder::Create() {
126 GLHelperHolder* holder = new GLHelperHolder; 152 GLHelperHolder* holder = new GLHelperHolder;
127 holder->Initialize(); 153 holder->Initialize();
128 return holder; 154 return holder;
129 } 155 }
130 156
131 void GLHelperHolder::Initialize() { 157 void GLHelperHolder::Initialize() {
132 auto* factory = BrowserGpuChannelHostFactory::instance(); 158 auto* factory = BrowserGpuChannelHostFactory::instance();
133 scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(factory->GetGpuChannel()); 159 scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(factory->GetGpuChannel());
134 160
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
177 if (!provider_->BindToCurrentThread()) 203 if (!provider_->BindToCurrentThread())
178 return; 204 return;
179 provider_->ContextGL()->TraceBeginCHROMIUM( 205 provider_->ContextGL()->TraceBeginCHROMIUM(
180 "gpu_toplevel", 206 "gpu_toplevel",
181 base::StringPrintf("CmdBufferImageTransportFactory-%p", provider_.get()) 207 base::StringPrintf("CmdBufferImageTransportFactory-%p", provider_.get())
182 .c_str()); 208 .c_str());
183 provider_->SetLostContextCallback( 209 provider_->SetLostContextCallback(
184 base::Bind(&GLHelperHolder::OnContextLost, base::Unretained(this))); 210 base::Bind(&GLHelperHolder::OnContextLost, base::Unretained(this)));
185 gl_helper_.reset(new display_compositor::GLHelper( 211 gl_helper_.reset(new display_compositor::GLHelper(
186 provider_->ContextGL(), provider_->ContextSupport())); 212 provider_->ContextGL(), provider_->ContextSupport()));
213
214 // Unretained() is safe because |this| owns the following two callbacks.
215 app_status_listener_.reset(new ApplicationStatusListener(base::Bind(
216 &GLHelperHolder::OnApplicationStatusChanged, base::Unretained(this))));
217 mem_pressure_listener_.reset(new MemoryPressureListener(base::Bind(
218 &GLHelperHolder::OnMemoryPressure, base::Unretained(this))));
219 }
220
221 void GLHelperHolder::FreeUnusedSharedMemoryIfNeeded() {
222 if (!has_running_or_paused_activities_ || did_signal_memory_pressure_)
223 provider_->FreeUnusedSharedMemory();
187 } 224 }
188 225
189 void GLHelperHolder::OnContextLost() { 226 void GLHelperHolder::OnContextLost() {
227 app_status_listener_.reset();
228 mem_pressure_listener_.reset();
229 gl_helper_.reset();
190 // Need to post a task because the command buffer client cannot be deleted 230 // Need to post a task because the command buffer client cannot be deleted
191 // from within this callback. 231 // from within this callback.
192 base::ThreadTaskRunnerHandle::Get()->PostTask( 232 base::ThreadTaskRunnerHandle::Get()->PostTask(
193 FROM_HERE, base::Bind(&RenderWidgetHostViewAndroid::OnContextLost)); 233 FROM_HERE, base::Bind(&RenderWidgetHostViewAndroid::OnContextLost));
194 } 234 }
195 235
196 // This can only be used for readback postprocessing. It may return null if the 236 void GLHelperHolder::OnApplicationStatusChanged(ApplicationState new_state) {
197 // channel was lost and not reestablished yet. 237 bool new_has_running_or_paused_activities =
198 display_compositor::GLHelper* GetPostReadbackGLHelper() { 238 new_state == base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES ||
239 new_state == base::android::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES;
240
241 if (!has_running_or_paused_activities_ &&
242 new_has_running_or_paused_activities) {
243 // Reset at this time since on Android there is no 'back to normal'
244 // notification (but only onTrim/onLowMemory).
245 did_signal_memory_pressure_ = false;
246 } else if (!new_has_running_or_paused_activities) {
247 provider_->FreeUnusedSharedMemory();
248 }
249
250 has_running_or_paused_activities_ = new_has_running_or_paused_activities;
251 }
252
253 void GLHelperHolder::OnMemoryPressure(
254 MemoryPressureListener::MemoryPressureLevel level) {
255 if (level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE ||
256 level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
257 did_signal_memory_pressure_ = true;
258 provider_->FreeUnusedSharedMemory();
259 }
260 }
261
262 GLHelperHolder* GetPostReadbackGLHelperHolder(bool create_if_necessary) {
199 static GLHelperHolder* g_readback_helper_holder = nullptr; 263 static GLHelperHolder* g_readback_helper_holder = nullptr;
200 264
265 if (!create_if_necessary && !g_readback_helper_holder)
266 return nullptr;
267
201 if (g_readback_helper_holder && g_readback_helper_holder->IsLost()) { 268 if (g_readback_helper_holder && g_readback_helper_holder->IsLost()) {
202 delete g_readback_helper_holder; 269 delete g_readback_helper_holder;
203 g_readback_helper_holder = nullptr; 270 g_readback_helper_holder = nullptr;
204 } 271 }
205 272
206 if (!g_readback_helper_holder) 273 if (!g_readback_helper_holder)
207 g_readback_helper_holder = GLHelperHolder::Create(); 274 g_readback_helper_holder = GLHelperHolder::Create();
208 275
209 return g_readback_helper_holder->gl_helper(); 276 return g_readback_helper_holder;
277 }
278
279 display_compositor::GLHelper* GetPostReadbackGLHelper() {
280 bool create_if_necessary = true;
281 return GetPostReadbackGLHelperHolder(create_if_necessary)->gl_helper();
282 }
283
284 void FreeUnusedGLHelperMemory() {
285 bool create_if_necessary = false;
286 GLHelperHolder* holder = GetPostReadbackGLHelperHolder(create_if_necessary);
287
288 if (holder) {
289 holder->FreeUnusedSharedMemoryIfNeeded();
290 }
210 } 291 }
211 292
212 void CopyFromCompositingSurfaceFinished( 293 void CopyFromCompositingSurfaceFinished(
213 const ReadbackRequestCallback& callback, 294 const ReadbackRequestCallback& callback,
214 std::unique_ptr<cc::SingleReleaseCallback> release_callback, 295 std::unique_ptr<cc::SingleReleaseCallback> release_callback,
215 std::unique_ptr<SkBitmap> bitmap, 296 std::unique_ptr<SkBitmap> bitmap,
216 const base::TimeTicks& start_time, 297 const base::TimeTicks& start_time,
217 std::unique_ptr<SkAutoLockPixels> bitmap_pixels_lock, 298 std::unique_ptr<SkAutoLockPixels> bitmap_pixels_lock,
218 bool result) { 299 bool result) {
219 TRACE_EVENT0( 300 TRACE_EVENT0(
220 "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished"); 301 "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished");
221 bitmap_pixels_lock.reset(); 302 bitmap_pixels_lock.reset();
222 gpu::SyncToken sync_token; 303 gpu::SyncToken sync_token;
223 if (result) { 304 if (result) {
224 display_compositor::GLHelper* gl_helper = GetPostReadbackGLHelper(); 305 display_compositor::GLHelper* gl_helper = GetPostReadbackGLHelper();
225 if (gl_helper) 306 if (gl_helper)
226 gl_helper->GenerateSyncToken(&sync_token); 307 gl_helper->GenerateSyncToken(&sync_token);
227 } 308 }
309
310 FreeUnusedGLHelperMemory();
311
228 const bool lost_resource = !sync_token.HasData(); 312 const bool lost_resource = !sync_token.HasData();
229 release_callback->Run(sync_token, lost_resource); 313 release_callback->Run(sync_token, lost_resource);
230 UMA_HISTOGRAM_TIMES(kAsyncReadBackString, 314 UMA_HISTOGRAM_TIMES(kAsyncReadBackString,
231 base::TimeTicks::Now() - start_time); 315 base::TimeTicks::Now() - start_time);
232 ReadbackResponse response = result ? READBACK_SUCCESS : READBACK_FAILED; 316 ReadbackResponse response = result ? READBACK_SUCCESS : READBACK_FAILED;
233 callback.Run(*bitmap, response); 317 callback.Run(*bitmap, response);
234 } 318 }
235 319
236 std::unique_ptr<ui::TouchSelectionController> CreateSelectionController( 320 std::unique_ptr<ui::TouchSelectionController> CreateSelectionController(
237 ui::TouchSelectionControllerClient* client, 321 ui::TouchSelectionControllerClient* client,
(...skipping 1642 matching lines...) Expand 10 before | Expand all | Expand 10 after
1880 case ui::MotionEvent::ACTION_UP: 1964 case ui::MotionEvent::ACTION_UP:
1881 case ui::MotionEvent::ACTION_POINTER_UP: 1965 case ui::MotionEvent::ACTION_POINTER_UP:
1882 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.OS.TOUCH_RELEASED", 1966 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.OS.TOUCH_RELEASED",
1883 delta.InMicroseconds(), 1, 1000000, 50); 1967 delta.InMicroseconds(), 1, 1000000, 50);
1884 default: 1968 default:
1885 return; 1969 return;
1886 } 1970 }
1887 } 1971 }
1888 1972
1889 } // namespace content 1973 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698