OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |