OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "android_webview/browser/in_process_view_renderer.h" | 5 #include "android_webview/browser/hardware_renderer.h" |
6 | 6 |
7 #include "android_webview/browser/aw_gl_surface.h" | 7 #include "android_webview/browser/aw_gl_surface.h" |
| 8 #include "android_webview/browser/browser_view_renderer.h" |
| 9 #include "android_webview/browser/gl_view_renderer_manager.h" |
8 #include "android_webview/browser/scoped_app_gl_state_restore.h" | 10 #include "android_webview/browser/scoped_app_gl_state_restore.h" |
9 #include "android_webview/common/aw_switches.h" | 11 #include "android_webview/common/aw_switches.h" |
10 #include "android_webview/public/browser/draw_gl.h" | 12 #include "android_webview/public/browser/draw_gl.h" |
11 #include "base/android/jni_android.h" | |
12 #include "base/auto_reset.h" | |
13 #include "base/command_line.h" | 13 #include "base/command_line.h" |
14 #include "base/debug/trace_event.h" | 14 #include "base/debug/trace_event.h" |
15 #include "base/lazy_instance.h" | |
16 #include "base/logging.h" | |
17 #include "base/strings/string_number_conversions.h" | 15 #include "base/strings/string_number_conversions.h" |
18 #include "base/strings/stringprintf.h" | |
19 #include "content/public/browser/browser_thread.h" | 16 #include "content/public/browser/browser_thread.h" |
20 #include "content/public/browser/web_contents.h" | |
21 #include "content/public/common/content_switches.h" | 17 #include "content/public/common/content_switches.h" |
22 #include "gpu/command_buffer/service/in_process_command_buffer.h" | |
23 #include "third_party/skia/include/core/SkBitmap.h" | |
24 #include "third_party/skia/include/core/SkBitmapDevice.h" | |
25 #include "third_party/skia/include/core/SkCanvas.h" | |
26 #include "third_party/skia/include/core/SkPicture.h" | |
27 #include "ui/gfx/transform.h" | 18 #include "ui/gfx/transform.h" |
28 #include "ui/gfx/vector2d_conversions.h" | 19 |
29 | |
30 using base::android::AttachCurrentThread; | |
31 using base::android::JavaRef; | |
32 using base::android::ScopedJavaLocalRef; | |
33 using content::BrowserThread; | 20 using content::BrowserThread; |
34 | 21 |
35 namespace android_webview { | 22 namespace android_webview { |
36 | 23 |
37 namespace { | 24 namespace { |
38 | 25 |
39 const void* kUserDataKey = &kUserDataKey; | |
40 | |
41 class UserData : public content::WebContents::Data { | |
42 public: | |
43 UserData(InProcessViewRenderer* ptr) : instance_(ptr) {} | |
44 virtual ~UserData() { | |
45 instance_->WebContentsGone(); | |
46 } | |
47 | |
48 static InProcessViewRenderer* GetInstance(content::WebContents* contents) { | |
49 if (!contents) | |
50 return NULL; | |
51 UserData* data = reinterpret_cast<UserData*>( | |
52 contents->GetUserData(kUserDataKey)); | |
53 return data ? data->instance_ : NULL; | |
54 } | |
55 | |
56 private: | |
57 InProcessViewRenderer* instance_; | |
58 }; | |
59 | |
60 bool HardwareEnabled() { | |
61 static bool g_hw_enabled = !CommandLine::ForCurrentProcess()->HasSwitch( | |
62 switches::kDisableWebViewGLMode); | |
63 return g_hw_enabled; | |
64 } | |
65 | |
66 const int64 kFallbackTickTimeoutInMilliseconds = 20; | |
67 | |
68 // Used to calculate memory and resource allocation. Determined experimentally. | 26 // Used to calculate memory and resource allocation. Determined experimentally. |
69 size_t g_memory_multiplier = 10; | 27 const size_t g_memory_multiplier = 10; |
70 size_t g_num_gralloc_limit = 150; | 28 const size_t g_num_gralloc_limit = 150; |
71 const size_t kBytesPerPixel = 4; | 29 const size_t kBytesPerPixel = 4; |
72 const size_t kMemoryAllocationStep = 5 * 1024 * 1024; | 30 const size_t kMemoryAllocationStep = 5 * 1024 * 1024; |
73 | 31 |
74 base::LazyInstance<GLViewRendererManager>::Leaky g_view_renderer_manager = | 32 base::LazyInstance<scoped_refptr<internal::DeferredGpuCommandService> > |
75 LAZY_INSTANCE_INITIALIZER; | 33 g_service = LAZY_INSTANCE_INITIALIZER; |
76 | 34 |
77 class ScopedAllowGL { | 35 } // namespace |
78 public: | 36 |
79 ScopedAllowGL(); | 37 DrawGLResult::DrawGLResult() |
80 ~ScopedAllowGL(); | 38 : did_draw(false), clip_contains_visible_rect(false) {} |
81 | 39 |
82 static bool IsAllowed() { | 40 HardwareRenderer::HardwareRenderer(content::SynchronousCompositor* compositor, |
83 return g_view_renderer_manager.Get().OnRenderThread() && allow_gl; | 41 BrowserViewRendererClient* client) |
84 } | 42 : compositor_(compositor), |
85 | 43 client_(client), |
86 private: | 44 last_egl_context_(eglGetCurrentContext()), |
87 static bool allow_gl; | 45 manager_key_(GLViewRendererManager::GetInstance()->NullKey()) { |
88 | 46 DCHECK(compositor_); |
89 DISALLOW_COPY_AND_ASSIGN(ScopedAllowGL); | 47 DCHECK(last_egl_context_); |
90 }; | 48 } |
| 49 |
| 50 HardwareRenderer::~HardwareRenderer() { |
| 51 GLViewRendererManager* mru = GLViewRendererManager::GetInstance(); |
| 52 if (manager_key_ != mru->NullKey()) { |
| 53 mru->NoLongerExpectsDrawGL(manager_key_); |
| 54 manager_key_ = mru->NullKey(); |
| 55 } |
| 56 |
| 57 if (gl_surface_) { |
| 58 ScopedAppGLStateRestore state_restore( |
| 59 ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT); |
| 60 internal::ScopedAllowGL allow_gl; |
| 61 |
| 62 compositor_->ReleaseHwDraw(); |
| 63 gl_surface_ = NULL; |
| 64 } |
| 65 DCHECK(manager_key_ == GLViewRendererManager::GetInstance()->NullKey()); |
| 66 } |
| 67 |
| 68 bool HardwareRenderer::InitializeHardwareDraw() { |
| 69 TRACE_EVENT0("android_webview", "InitializeHardwareDraw"); |
| 70 if (!g_service.Get()) { |
| 71 g_service.Get() = new internal::DeferredGpuCommandService; |
| 72 content::SynchronousCompositor::SetGpuService(g_service.Get()); |
| 73 } |
| 74 |
| 75 bool success = true; |
| 76 if (!gl_surface_) { |
| 77 scoped_refptr<AwGLSurface> gl_surface = new AwGLSurface; |
| 78 success = compositor_->InitializeHwDraw(gl_surface); |
| 79 if (success) |
| 80 gl_surface_ = gl_surface; |
| 81 } |
| 82 |
| 83 return success; |
| 84 } |
| 85 |
| 86 DrawGLResult HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info, |
| 87 const DrawGLInput& input) { |
| 88 TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL"); |
| 89 manager_key_ = |
| 90 GLViewRendererManager::GetInstance()->DidDrawGL(manager_key_, this); |
| 91 DrawGLResult result; |
| 92 |
| 93 // We need to watch if the current Android context has changed and enforce |
| 94 // a clean-up in the compositor. |
| 95 EGLContext current_context = eglGetCurrentContext(); |
| 96 if (!current_context) { |
| 97 DLOG(ERROR) << "DrawGL called without EGLContext"; |
| 98 return result; |
| 99 } |
| 100 |
| 101 // TODO(boliu): Handle context loss. |
| 102 if (last_egl_context_ != current_context) |
| 103 DLOG(WARNING) << "EGLContextChanged"; |
| 104 |
| 105 ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_DRAW); |
| 106 internal::ScopedAllowGL allow_gl; |
| 107 |
| 108 if (draw_info->mode == AwDrawGLInfo::kModeProcess) |
| 109 return result; |
| 110 |
| 111 if (!InitializeHardwareDraw()) { |
| 112 DLOG(ERROR) << "WebView hardware initialization failed"; |
| 113 return result; |
| 114 } |
| 115 |
| 116 // Update memory budget. This will no-op in compositor if the policy has not |
| 117 // changed since last draw. |
| 118 content::SynchronousCompositorMemoryPolicy policy; |
| 119 policy.bytes_limit = g_memory_multiplier * kBytesPerPixel * |
| 120 input.global_visible_rect.width() * |
| 121 input.global_visible_rect.height(); |
| 122 // Round up to a multiple of kMemoryAllocationStep. |
| 123 policy.bytes_limit = |
| 124 (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep; |
| 125 policy.num_resources_limit = g_num_gralloc_limit; |
| 126 SetMemoryPolicy(policy); |
| 127 |
| 128 gl_surface_->SetBackingFrameBufferObject( |
| 129 state_restore.framebuffer_binding_ext()); |
| 130 |
| 131 gfx::Transform transform; |
| 132 transform.matrix().setColMajorf(draw_info->transform); |
| 133 transform.Translate(input.scroll.x(), input.scroll.y()); |
| 134 gfx::Rect clip_rect(draw_info->clip_left, |
| 135 draw_info->clip_top, |
| 136 draw_info->clip_right - draw_info->clip_left, |
| 137 draw_info->clip_bottom - draw_info->clip_top); |
| 138 |
| 139 gfx::Rect viewport_rect; |
| 140 if (draw_info->is_layer) { |
| 141 viewport_rect = clip_rect; |
| 142 } else { |
| 143 viewport_rect = input.global_visible_rect; |
| 144 clip_rect.Intersect(viewport_rect); |
| 145 } |
| 146 result.clip_contains_visible_rect = clip_rect.Contains(viewport_rect); |
| 147 |
| 148 result.did_draw = |
| 149 compositor_->DemandDrawHw(gfx::Size(draw_info->width, draw_info->height), |
| 150 transform, |
| 151 viewport_rect, |
| 152 clip_rect, |
| 153 state_restore.stencil_enabled()); |
| 154 gl_surface_->ResetBackingFrameBufferObject(); |
| 155 |
| 156 return result; |
| 157 } |
| 158 |
| 159 bool HardwareRenderer::TrimMemory(int level, bool visible) { |
| 160 // Constants from Android ComponentCallbacks2. |
| 161 enum { |
| 162 TRIM_MEMORY_RUNNING_LOW = 10, |
| 163 TRIM_MEMORY_UI_HIDDEN = 20, |
| 164 TRIM_MEMORY_BACKGROUND = 40, |
| 165 }; |
| 166 |
| 167 // Not urgent enough. TRIM_MEMORY_UI_HIDDEN is treated specially because |
| 168 // it does not indicate memory pressure, but merely that the app is |
| 169 // backgrounded. |
| 170 if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN) |
| 171 return false; |
| 172 |
| 173 // Do not release resources on view we expect to get DrawGL soon. |
| 174 if (level < TRIM_MEMORY_BACKGROUND && visible) |
| 175 return false; |
| 176 |
| 177 if (!eglGetCurrentContext()) { |
| 178 NOTREACHED(); |
| 179 return false; |
| 180 } |
| 181 |
| 182 DCHECK_EQ(last_egl_context_, eglGetCurrentContext()); |
| 183 |
| 184 // Just set the memory limit to 0 and drop all tiles. This will be reset to |
| 185 // normal levels in the next DrawGL call. |
| 186 content::SynchronousCompositorMemoryPolicy policy; |
| 187 policy.bytes_limit = 0; |
| 188 policy.num_resources_limit = 0; |
| 189 if (memory_policy_ == policy) |
| 190 return false; |
| 191 |
| 192 TRACE_EVENT0("android_webview", "BrowserViewRenderer::TrimMemory"); |
| 193 ScopedAppGLStateRestore state_restore( |
| 194 ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT); |
| 195 internal::ScopedAllowGL allow_gl; |
| 196 |
| 197 SetMemoryPolicy(policy); |
| 198 return true; |
| 199 } |
| 200 |
| 201 void HardwareRenderer::SetMemoryPolicy( |
| 202 content::SynchronousCompositorMemoryPolicy& new_policy) { |
| 203 if (memory_policy_ == new_policy) |
| 204 return; |
| 205 |
| 206 memory_policy_ = new_policy; |
| 207 compositor_->SetMemoryPolicy(memory_policy_); |
| 208 } |
| 209 |
| 210 bool HardwareRenderer::RequestDrawGL() { |
| 211 return client_->RequestDrawGL(NULL); |
| 212 } |
| 213 |
| 214 // static |
| 215 void HardwareRenderer::CalculateTileMemoryPolicy() { |
| 216 CommandLine* cl = CommandLine::ForCurrentProcess(); |
| 217 |
| 218 const char kDefaultTileSize[] = "384"; |
| 219 if (!cl->HasSwitch(switches::kDefaultTileWidth)) |
| 220 cl->AppendSwitchASCII(switches::kDefaultTileWidth, kDefaultTileSize); |
| 221 |
| 222 if (!cl->HasSwitch(switches::kDefaultTileHeight)) |
| 223 cl->AppendSwitchASCII(switches::kDefaultTileHeight, kDefaultTileSize); |
| 224 } |
| 225 |
| 226 namespace internal { |
| 227 |
| 228 bool ScopedAllowGL::allow_gl = false; |
| 229 |
| 230 // static |
| 231 bool ScopedAllowGL::IsAllowed() { |
| 232 return GLViewRendererManager::GetInstance()->OnRenderThread() && allow_gl; |
| 233 } |
91 | 234 |
92 ScopedAllowGL::ScopedAllowGL() { | 235 ScopedAllowGL::ScopedAllowGL() { |
93 DCHECK(g_view_renderer_manager.Get().OnRenderThread()); | 236 DCHECK(GLViewRendererManager::GetInstance()->OnRenderThread()); |
94 DCHECK(!allow_gl); | 237 DCHECK(!allow_gl); |
95 allow_gl = true; | 238 allow_gl = true; |
96 } | 239 |
97 | 240 if (g_service.Get()) |
98 ScopedAllowGL::~ScopedAllowGL() { | 241 g_service.Get()->RunTasks(); |
99 allow_gl = false; | 242 } |
100 } | 243 |
101 | 244 ScopedAllowGL::~ScopedAllowGL() { allow_gl = false; } |
102 bool ScopedAllowGL::allow_gl = false; | |
103 | |
104 void RequestProcessGLOnUIThread() { | |
105 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
106 BrowserThread::PostTask( | |
107 BrowserThread::UI, FROM_HERE, base::Bind(&RequestProcessGLOnUIThread)); | |
108 return; | |
109 } | |
110 | |
111 InProcessViewRenderer* renderer = static_cast<InProcessViewRenderer*>( | |
112 g_view_renderer_manager.Get().GetMostRecentlyDrawn()); | |
113 if (!renderer || !renderer->RequestProcessGL()) { | |
114 LOG(ERROR) << "Failed to request GL process. Deadlock likely: " | |
115 << !!renderer; | |
116 } | |
117 } | |
118 | |
119 class DeferredGpuCommandService | |
120 : public gpu::InProcessCommandBuffer::Service, | |
121 public base::RefCountedThreadSafe<DeferredGpuCommandService> { | |
122 public: | |
123 DeferredGpuCommandService(); | |
124 | |
125 virtual void ScheduleTask(const base::Closure& task) OVERRIDE; | |
126 virtual void ScheduleIdleWork(const base::Closure& task) OVERRIDE; | |
127 virtual bool UseVirtualizedGLContexts() OVERRIDE; | |
128 | |
129 void RunTasks(); | |
130 | |
131 virtual void AddRef() const OVERRIDE { | |
132 base::RefCountedThreadSafe<DeferredGpuCommandService>::AddRef(); | |
133 } | |
134 virtual void Release() const OVERRIDE { | |
135 base::RefCountedThreadSafe<DeferredGpuCommandService>::Release(); | |
136 } | |
137 | |
138 protected: | |
139 virtual ~DeferredGpuCommandService(); | |
140 friend class base::RefCountedThreadSafe<DeferredGpuCommandService>; | |
141 | |
142 private: | |
143 base::Lock tasks_lock_; | |
144 std::queue<base::Closure> tasks_; | |
145 DISALLOW_COPY_AND_ASSIGN(DeferredGpuCommandService); | |
146 }; | |
147 | 245 |
148 DeferredGpuCommandService::DeferredGpuCommandService() {} | 246 DeferredGpuCommandService::DeferredGpuCommandService() {} |
149 | 247 |
150 DeferredGpuCommandService::~DeferredGpuCommandService() { | 248 DeferredGpuCommandService::~DeferredGpuCommandService() { |
151 base::AutoLock lock(tasks_lock_); | 249 base::AutoLock lock(tasks_lock_); |
152 DCHECK(tasks_.empty()); | 250 DCHECK(tasks_.empty()); |
153 } | 251 } |
154 | 252 |
| 253 namespace { |
| 254 void RequestProcessGL() { |
| 255 HardwareRenderer* renderer = |
| 256 GLViewRendererManager::GetInstance()->GetMostRecentlyDrawn(); |
| 257 if (!renderer || !renderer->RequestDrawGL()) { |
| 258 LOG(ERROR) << "Failed to request GL process. Deadlock likely: " |
| 259 << !!renderer; |
| 260 } |
| 261 } |
| 262 } // namespace |
| 263 |
| 264 // static |
| 265 void DeferredGpuCommandService::RequestProcessGLOnUIThread() { |
| 266 if (BrowserThread::CurrentlyOn(BrowserThread::UI)) { |
| 267 RequestProcessGL(); |
| 268 } else { |
| 269 BrowserThread::PostTask( |
| 270 BrowserThread::UI, FROM_HERE, base::Bind(&RequestProcessGL)); |
| 271 } |
| 272 } |
| 273 |
155 // Called from different threads! | 274 // Called from different threads! |
156 void DeferredGpuCommandService::ScheduleTask(const base::Closure& task) { | 275 void DeferredGpuCommandService::ScheduleTask(const base::Closure& task) { |
157 { | 276 { |
158 base::AutoLock lock(tasks_lock_); | 277 base::AutoLock lock(tasks_lock_); |
159 tasks_.push(task); | 278 tasks_.push(task); |
160 } | 279 } |
161 if (ScopedAllowGL::IsAllowed()) { | 280 if (ScopedAllowGL::IsAllowed()) { |
162 RunTasks(); | 281 RunTasks(); |
163 } else { | 282 } else { |
164 RequestProcessGLOnUIThread(); | 283 RequestProcessGLOnUIThread(); |
(...skipping 19 matching lines...) Expand all Loading... |
184 { | 303 { |
185 base::AutoLock lock(tasks_lock_); | 304 base::AutoLock lock(tasks_lock_); |
186 task = tasks_.front(); | 305 task = tasks_.front(); |
187 tasks_.pop(); | 306 tasks_.pop(); |
188 } | 307 } |
189 task.Run(); | 308 task.Run(); |
190 { | 309 { |
191 base::AutoLock lock(tasks_lock_); | 310 base::AutoLock lock(tasks_lock_); |
192 has_more_tasks = tasks_.size() > 0; | 311 has_more_tasks = tasks_.size() > 0; |
193 } | 312 } |
194 | 313 } |
195 } | 314 } |
196 } | 315 |
197 | 316 void DeferredGpuCommandService::AddRef() const { |
198 base::LazyInstance<scoped_refptr<DeferredGpuCommandService> > g_service = | 317 base::RefCountedThreadSafe<DeferredGpuCommandService>::AddRef(); |
199 LAZY_INSTANCE_INITIALIZER; | 318 } |
200 | 319 |
201 } // namespace | 320 void DeferredGpuCommandService::Release() const { |
202 | 321 base::RefCountedThreadSafe<DeferredGpuCommandService>::Release(); |
203 InProcessViewRenderer::InProcessViewRenderer( | 322 } |
204 BrowserViewRenderer::Client* client, | 323 |
205 content::WebContents* web_contents) | 324 } // namespace internal |
206 : client_(client), | |
207 web_contents_(web_contents), | |
208 compositor_(NULL), | |
209 is_paused_(false), | |
210 view_visible_(false), | |
211 window_visible_(false), | |
212 attached_to_window_(false), | |
213 dip_scale_(0.0), | |
214 page_scale_factor_(1.0), | |
215 on_new_picture_enable_(false), | |
216 clear_view_(false), | |
217 compositor_needs_continuous_invalidate_(false), | |
218 block_invalidates_(false), | |
219 width_(0), | |
220 height_(0), | |
221 hardware_initialized_(false), | |
222 hardware_failed_(false), | |
223 last_egl_context_(NULL), | |
224 manager_key_(g_view_renderer_manager.Get().NullKey()) { | |
225 CHECK(web_contents_); | |
226 web_contents_->SetUserData(kUserDataKey, new UserData(this)); | |
227 content::SynchronousCompositor::SetClientForWebContents(web_contents_, this); | |
228 | |
229 // Currently the logic in this class relies on |compositor_| remaining NULL | |
230 // until the DidInitializeCompositor() call, hence it is not set here. | |
231 } | |
232 | |
233 InProcessViewRenderer::~InProcessViewRenderer() { | |
234 CHECK(web_contents_); | |
235 content::SynchronousCompositor::SetClientForWebContents(web_contents_, NULL); | |
236 web_contents_->SetUserData(kUserDataKey, NULL); | |
237 NoLongerExpectsDrawGL(); | |
238 DCHECK(web_contents_ == NULL); // WebContentsGone should have been called. | |
239 } | |
240 | |
241 void InProcessViewRenderer::NoLongerExpectsDrawGL() { | |
242 GLViewRendererManager& mru = g_view_renderer_manager.Get(); | |
243 if (manager_key_ != mru.NullKey()) { | |
244 mru.NoLongerExpectsDrawGL(manager_key_); | |
245 manager_key_ = mru.NullKey(); | |
246 } | |
247 } | |
248 | |
249 // static | |
250 InProcessViewRenderer* InProcessViewRenderer::FromWebContents( | |
251 content::WebContents* contents) { | |
252 return UserData::GetInstance(contents); | |
253 } | |
254 | |
255 void InProcessViewRenderer::WebContentsGone() { | |
256 web_contents_ = NULL; | |
257 compositor_ = NULL; | |
258 } | |
259 | |
260 // static | |
261 void InProcessViewRenderer::CalculateTileMemoryPolicy() { | |
262 CommandLine* cl = CommandLine::ForCurrentProcess(); | |
263 if (cl->HasSwitch(switches::kTileMemoryMultiplier)) { | |
264 std::string string_value = | |
265 cl->GetSwitchValueASCII(switches::kTileMemoryMultiplier); | |
266 int int_value = 0; | |
267 if (base::StringToInt(string_value, &int_value) && | |
268 int_value >= 2 && int_value <= 50) { | |
269 g_memory_multiplier = int_value; | |
270 } | |
271 } | |
272 | |
273 if (cl->HasSwitch(switches::kNumGrallocBuffersPerWebview)) { | |
274 std::string string_value = | |
275 cl->GetSwitchValueASCII(switches::kNumGrallocBuffersPerWebview); | |
276 int int_value = 0; | |
277 if (base::StringToInt(string_value, &int_value) && | |
278 int_value >= 50 && int_value <= 500) { | |
279 g_num_gralloc_limit = int_value; | |
280 } | |
281 } | |
282 | |
283 const char kDefaultTileSize[] = "384"; | |
284 if (!cl->HasSwitch(switches::kDefaultTileWidth)) | |
285 cl->AppendSwitchASCII(switches::kDefaultTileWidth, kDefaultTileSize); | |
286 | |
287 if (!cl->HasSwitch(switches::kDefaultTileHeight)) | |
288 cl->AppendSwitchASCII(switches::kDefaultTileHeight, kDefaultTileSize); | |
289 } | |
290 | |
291 bool InProcessViewRenderer::RequestProcessGL() { | |
292 return client_->RequestDrawGL(NULL); | |
293 } | |
294 | |
295 void InProcessViewRenderer::TrimMemory(int level) { | |
296 // Constants from Android ComponentCallbacks2. | |
297 enum { | |
298 TRIM_MEMORY_RUNNING_LOW = 10, | |
299 TRIM_MEMORY_UI_HIDDEN = 20, | |
300 TRIM_MEMORY_BACKGROUND = 40, | |
301 }; | |
302 | |
303 // Not urgent enough. TRIM_MEMORY_UI_HIDDEN is treated specially because | |
304 // it does not indicate memory pressure, but merely that the app is | |
305 // backgrounded. | |
306 if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN) | |
307 return; | |
308 | |
309 // Nothing to drop. | |
310 if (!attached_to_window_ || !hardware_initialized_ || !compositor_) | |
311 return; | |
312 | |
313 // Do not release resources on view we expect to get DrawGL soon. | |
314 if (level < TRIM_MEMORY_BACKGROUND) { | |
315 client_->UpdateGlobalVisibleRect(); | |
316 if (view_visible_ && window_visible_ && | |
317 !cached_global_visible_rect_.IsEmpty()) { | |
318 return; | |
319 } | |
320 } | |
321 | |
322 if (!eglGetCurrentContext()) { | |
323 NOTREACHED(); | |
324 return; | |
325 } | |
326 | |
327 // Just set the memory limit to 0 and drop all tiles. This will be reset to | |
328 // normal levels in the next DrawGL call. | |
329 content::SynchronousCompositorMemoryPolicy policy; | |
330 policy.bytes_limit = 0; | |
331 policy.num_resources_limit = 0; | |
332 if (memory_policy_ == policy) | |
333 return; | |
334 | |
335 TRACE_EVENT0("android_webview", "InProcessViewRenderer::TrimMemory"); | |
336 ScopedAppGLStateRestore state_restore( | |
337 ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT); | |
338 g_service.Get()->RunTasks(); | |
339 ScopedAllowGL allow_gl; | |
340 | |
341 SetMemoryPolicy(policy); | |
342 ForceFakeCompositeSW(); | |
343 } | |
344 | |
345 void InProcessViewRenderer::SetMemoryPolicy( | |
346 content::SynchronousCompositorMemoryPolicy& new_policy) { | |
347 if (memory_policy_ == new_policy) | |
348 return; | |
349 | |
350 memory_policy_ = new_policy; | |
351 compositor_->SetMemoryPolicy(memory_policy_); | |
352 } | |
353 | |
354 void InProcessViewRenderer::UpdateCachedGlobalVisibleRect() { | |
355 client_->UpdateGlobalVisibleRect(); | |
356 } | |
357 | |
358 bool InProcessViewRenderer::OnDraw(jobject java_canvas, | |
359 bool is_hardware_canvas, | |
360 const gfx::Vector2d& scroll, | |
361 const gfx::Rect& clip) { | |
362 scroll_at_start_of_frame_ = scroll; | |
363 if (clear_view_) | |
364 return false; | |
365 if (is_hardware_canvas && attached_to_window_ && HardwareEnabled()) { | |
366 // We should be performing a hardware draw here. If we don't have the | |
367 // comositor yet or if RequestDrawGL fails, it means we failed this draw and | |
368 // thus return false here to clear to background color for this draw. | |
369 return compositor_ && client_->RequestDrawGL(java_canvas); | |
370 } | |
371 // Perform a software draw | |
372 return DrawSWInternal(java_canvas, clip); | |
373 } | |
374 | |
375 bool InProcessViewRenderer::InitializeHwDraw() { | |
376 TRACE_EVENT0("android_webview", "InitializeHwDraw"); | |
377 DCHECK(!gl_surface_); | |
378 gl_surface_ = new AwGLSurface; | |
379 if (!g_service.Get()) { | |
380 g_service.Get() = new DeferredGpuCommandService; | |
381 content::SynchronousCompositor::SetGpuService(g_service.Get()); | |
382 } | |
383 hardware_failed_ = !compositor_->InitializeHwDraw(gl_surface_); | |
384 hardware_initialized_ = true; | |
385 | |
386 if (hardware_failed_) | |
387 gl_surface_ = NULL; | |
388 | |
389 return !hardware_failed_; | |
390 } | |
391 | |
392 void InProcessViewRenderer::DrawGL(AwDrawGLInfo* draw_info) { | |
393 TRACE_EVENT0("android_webview", "InProcessViewRenderer::DrawGL"); | |
394 | |
395 manager_key_ = g_view_renderer_manager.Get().DidDrawGL(manager_key_, this); | |
396 | |
397 // We need to watch if the current Android context has changed and enforce | |
398 // a clean-up in the compositor. | |
399 EGLContext current_context = eglGetCurrentContext(); | |
400 if (!current_context) { | |
401 TRACE_EVENT_INSTANT0( | |
402 "android_webview", "EarlyOut_NullEGLContext", TRACE_EVENT_SCOPE_THREAD); | |
403 return; | |
404 } | |
405 | |
406 ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_DRAW); | |
407 if (g_service.Get()) | |
408 g_service.Get()->RunTasks(); | |
409 ScopedAllowGL allow_gl; | |
410 | |
411 if (!attached_to_window_) { | |
412 TRACE_EVENT_INSTANT0( | |
413 "android_webview", "EarlyOut_NotAttached", TRACE_EVENT_SCOPE_THREAD); | |
414 return; | |
415 } | |
416 | |
417 if (draw_info->mode == AwDrawGLInfo::kModeProcess) { | |
418 TRACE_EVENT_INSTANT0( | |
419 "android_webview", "EarlyOut_ModeProcess", TRACE_EVENT_SCOPE_THREAD); | |
420 return; | |
421 } | |
422 | |
423 if (compositor_ && !hardware_initialized_) { | |
424 if (InitializeHwDraw()) { | |
425 last_egl_context_ = current_context; | |
426 } else { | |
427 TRACE_EVENT_INSTANT0( | |
428 "android_webview", "EarlyOut_HwInitFail", TRACE_EVENT_SCOPE_THREAD); | |
429 LOG(ERROR) << "WebView hardware initialization failed"; | |
430 return; | |
431 } | |
432 } | |
433 | |
434 UpdateCachedGlobalVisibleRect(); | |
435 if (cached_global_visible_rect_.IsEmpty()) { | |
436 TRACE_EVENT_INSTANT0("android_webview", | |
437 "EarlyOut_EmptyVisibleRect", | |
438 TRACE_EVENT_SCOPE_THREAD); | |
439 return; | |
440 } | |
441 | |
442 if (last_egl_context_ != current_context) { | |
443 // TODO(boliu): Handle context lost | |
444 TRACE_EVENT_INSTANT0( | |
445 "android_webview", "EGLContextChanged", TRACE_EVENT_SCOPE_THREAD); | |
446 } | |
447 | |
448 if (!compositor_) { | |
449 TRACE_EVENT_INSTANT0( | |
450 "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD); | |
451 return; | |
452 } | |
453 | |
454 // DrawGL may be called without OnDraw, so cancel |fallback_tick_| here as | |
455 // well just to be safe. | |
456 fallback_tick_.Cancel(); | |
457 | |
458 // Update memory budget. This will no-op in compositor if the policy has not | |
459 // changed since last draw. | |
460 content::SynchronousCompositorMemoryPolicy policy; | |
461 policy.bytes_limit = g_memory_multiplier * kBytesPerPixel * | |
462 cached_global_visible_rect_.width() * | |
463 cached_global_visible_rect_.height(); | |
464 // Round up to a multiple of kMemoryAllocationStep. | |
465 policy.bytes_limit = | |
466 (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep; | |
467 policy.num_resources_limit = g_num_gralloc_limit; | |
468 SetMemoryPolicy(policy); | |
469 | |
470 DCHECK(gl_surface_); | |
471 gl_surface_->SetBackingFrameBufferObject( | |
472 state_restore.framebuffer_binding_ext()); | |
473 | |
474 gfx::Transform transform; | |
475 transform.matrix().setColMajorf(draw_info->transform); | |
476 transform.Translate(scroll_at_start_of_frame_.x(), | |
477 scroll_at_start_of_frame_.y()); | |
478 gfx::Rect clip_rect(draw_info->clip_left, | |
479 draw_info->clip_top, | |
480 draw_info->clip_right - draw_info->clip_left, | |
481 draw_info->clip_bottom - draw_info->clip_top); | |
482 | |
483 // Assume we always draw the full visible rect if we are drawing into a layer. | |
484 bool drew_full_visible_rect = true; | |
485 | |
486 gfx::Rect viewport_rect; | |
487 if (!draw_info->is_layer) { | |
488 viewport_rect = cached_global_visible_rect_; | |
489 clip_rect.Intersect(viewport_rect); | |
490 drew_full_visible_rect = clip_rect.Contains(viewport_rect); | |
491 } else { | |
492 viewport_rect = clip_rect; | |
493 } | |
494 | |
495 block_invalidates_ = true; | |
496 // TODO(joth): Check return value. | |
497 compositor_->DemandDrawHw(gfx::Size(draw_info->width, draw_info->height), | |
498 transform, | |
499 viewport_rect, | |
500 clip_rect, | |
501 state_restore.stencil_enabled()); | |
502 block_invalidates_ = false; | |
503 gl_surface_->ResetBackingFrameBufferObject(); | |
504 | |
505 EnsureContinuousInvalidation(draw_info, !drew_full_visible_rect); | |
506 } | |
507 | |
508 void InProcessViewRenderer::SetGlobalVisibleRect( | |
509 const gfx::Rect& visible_rect) { | |
510 cached_global_visible_rect_ = visible_rect; | |
511 } | |
512 | |
513 bool InProcessViewRenderer::DrawSWInternal(jobject java_canvas, | |
514 const gfx::Rect& clip) { | |
515 if (clip.IsEmpty()) { | |
516 TRACE_EVENT_INSTANT0( | |
517 "android_webview", "EarlyOut_EmptyClip", TRACE_EVENT_SCOPE_THREAD); | |
518 return true; | |
519 } | |
520 | |
521 if (!compositor_) { | |
522 TRACE_EVENT_INSTANT0( | |
523 "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD); | |
524 return false; | |
525 } | |
526 | |
527 return JavaHelper::GetInstance()->RenderViaAuxilaryBitmapIfNeeded( | |
528 java_canvas, | |
529 scroll_at_start_of_frame_, | |
530 clip, | |
531 base::Bind(&InProcessViewRenderer::CompositeSW, base::Unretained(this))); | |
532 } | |
533 | |
534 skia::RefPtr<SkPicture> InProcessViewRenderer::CapturePicture(int width, | |
535 int height) { | |
536 TRACE_EVENT0("android_webview", "InProcessViewRenderer::CapturePicture"); | |
537 | |
538 // Return empty Picture objects for empty SkPictures. | |
539 skia::RefPtr<SkPicture> picture = skia::AdoptRef(new SkPicture); | |
540 if (width <= 0 || height <= 0) { | |
541 return picture; | |
542 } | |
543 | |
544 // Reset scroll back to the origin, will go back to the old | |
545 // value when scroll_reset is out of scope. | |
546 base::AutoReset<gfx::Vector2dF> scroll_reset(&scroll_offset_dip_, | |
547 gfx::Vector2d()); | |
548 | |
549 SkCanvas* rec_canvas = picture->beginRecording(width, height, 0); | |
550 if (compositor_) | |
551 CompositeSW(rec_canvas); | |
552 picture->endRecording(); | |
553 return picture; | |
554 } | |
555 | |
556 void InProcessViewRenderer::EnableOnNewPicture(bool enabled) { | |
557 on_new_picture_enable_ = enabled; | |
558 EnsureContinuousInvalidation(NULL, false); | |
559 } | |
560 | |
561 void InProcessViewRenderer::ClearView() { | |
562 TRACE_EVENT_INSTANT0("android_webview", | |
563 "InProcessViewRenderer::ClearView", | |
564 TRACE_EVENT_SCOPE_THREAD); | |
565 if (clear_view_) | |
566 return; | |
567 | |
568 clear_view_ = true; | |
569 // Always invalidate ignoring the compositor to actually clear the webview. | |
570 EnsureContinuousInvalidation(NULL, true); | |
571 } | |
572 | |
573 void InProcessViewRenderer::SetIsPaused(bool paused) { | |
574 TRACE_EVENT_INSTANT1("android_webview", | |
575 "InProcessViewRenderer::SetIsPaused", | |
576 TRACE_EVENT_SCOPE_THREAD, | |
577 "paused", | |
578 paused); | |
579 is_paused_ = paused; | |
580 EnsureContinuousInvalidation(NULL, false); | |
581 } | |
582 | |
583 void InProcessViewRenderer::SetViewVisibility(bool view_visible) { | |
584 TRACE_EVENT_INSTANT1("android_webview", | |
585 "InProcessViewRenderer::SetViewVisibility", | |
586 TRACE_EVENT_SCOPE_THREAD, | |
587 "view_visible", | |
588 view_visible); | |
589 view_visible_ = view_visible; | |
590 } | |
591 | |
592 void InProcessViewRenderer::SetWindowVisibility(bool window_visible) { | |
593 TRACE_EVENT_INSTANT1("android_webview", | |
594 "InProcessViewRenderer::SetWindowVisibility", | |
595 TRACE_EVENT_SCOPE_THREAD, | |
596 "window_visible", | |
597 window_visible); | |
598 window_visible_ = window_visible; | |
599 EnsureContinuousInvalidation(NULL, false); | |
600 } | |
601 | |
602 void InProcessViewRenderer::OnSizeChanged(int width, int height) { | |
603 TRACE_EVENT_INSTANT2("android_webview", | |
604 "InProcessViewRenderer::OnSizeChanged", | |
605 TRACE_EVENT_SCOPE_THREAD, | |
606 "width", | |
607 width, | |
608 "height", | |
609 height); | |
610 width_ = width; | |
611 height_ = height; | |
612 } | |
613 | |
614 void InProcessViewRenderer::OnAttachedToWindow(int width, int height) { | |
615 TRACE_EVENT2("android_webview", | |
616 "InProcessViewRenderer::OnAttachedToWindow", | |
617 "width", | |
618 width, | |
619 "height", | |
620 height); | |
621 attached_to_window_ = true; | |
622 width_ = width; | |
623 height_ = height; | |
624 } | |
625 | |
626 void InProcessViewRenderer::OnDetachedFromWindow() { | |
627 TRACE_EVENT0("android_webview", | |
628 "InProcessViewRenderer::OnDetachedFromWindow"); | |
629 | |
630 NoLongerExpectsDrawGL(); | |
631 if (hardware_initialized_) { | |
632 DCHECK(compositor_); | |
633 | |
634 ScopedAppGLStateRestore state_restore( | |
635 ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT); | |
636 g_service.Get()->RunTasks(); | |
637 ScopedAllowGL allow_gl; | |
638 compositor_->ReleaseHwDraw(); | |
639 hardware_initialized_ = false; | |
640 } | |
641 | |
642 gl_surface_ = NULL; | |
643 attached_to_window_ = false; | |
644 } | |
645 | |
646 bool InProcessViewRenderer::IsAttachedToWindow() { | |
647 return attached_to_window_; | |
648 } | |
649 | |
650 bool InProcessViewRenderer::IsVisible() { | |
651 // Ignore |window_visible_| if |attached_to_window_| is false. | |
652 return view_visible_ && (!attached_to_window_ || window_visible_); | |
653 } | |
654 | |
655 gfx::Rect InProcessViewRenderer::GetScreenRect() { | |
656 return gfx::Rect(client_->GetLocationOnScreen(), gfx::Size(width_, height_)); | |
657 } | |
658 | |
659 void InProcessViewRenderer::DidInitializeCompositor( | |
660 content::SynchronousCompositor* compositor) { | |
661 TRACE_EVENT0("android_webview", | |
662 "InProcessViewRenderer::DidInitializeCompositor"); | |
663 DCHECK(compositor && compositor_ == NULL); | |
664 compositor_ = compositor; | |
665 hardware_initialized_ = false; | |
666 hardware_failed_ = false; | |
667 } | |
668 | |
669 void InProcessViewRenderer::DidDestroyCompositor( | |
670 content::SynchronousCompositor* compositor) { | |
671 TRACE_EVENT0("android_webview", | |
672 "InProcessViewRenderer::DidDestroyCompositor"); | |
673 DCHECK(compositor_ == compositor); | |
674 | |
675 // This can fail if Apps call destroy while the webview is still attached | |
676 // to the view tree. This is an illegal operation that will lead to leaks. | |
677 // Log for now. Consider a proper fix if this becomes a problem. | |
678 LOG_IF(ERROR, hardware_initialized_) | |
679 << "Destroy called before OnDetachedFromWindow. May Leak GL resources"; | |
680 compositor_ = NULL; | |
681 } | |
682 | |
683 void InProcessViewRenderer::SetContinuousInvalidate(bool invalidate) { | |
684 if (compositor_needs_continuous_invalidate_ == invalidate) | |
685 return; | |
686 | |
687 TRACE_EVENT_INSTANT1("android_webview", | |
688 "InProcessViewRenderer::SetContinuousInvalidate", | |
689 TRACE_EVENT_SCOPE_THREAD, | |
690 "invalidate", | |
691 invalidate); | |
692 compositor_needs_continuous_invalidate_ = invalidate; | |
693 EnsureContinuousInvalidation(NULL, false); | |
694 } | |
695 | |
696 void InProcessViewRenderer::SetDipScale(float dip_scale) { | |
697 dip_scale_ = dip_scale; | |
698 CHECK(dip_scale_ > 0); | |
699 } | |
700 | |
701 gfx::Vector2d InProcessViewRenderer::max_scroll_offset() const { | |
702 DCHECK_GT(dip_scale_, 0); | |
703 return gfx::ToCeiledVector2d(gfx::ScaleVector2d( | |
704 max_scroll_offset_dip_, dip_scale_ * page_scale_factor_)); | |
705 } | |
706 | |
707 void InProcessViewRenderer::ScrollTo(gfx::Vector2d scroll_offset) { | |
708 gfx::Vector2d max_offset = max_scroll_offset(); | |
709 gfx::Vector2dF scroll_offset_dip; | |
710 // To preserve the invariant that scrolling to the maximum physical pixel | |
711 // value also scrolls to the maximum dip pixel value we transform the physical | |
712 // offset into the dip offset by using a proportion (instead of dividing by | |
713 // dip_scale * page_scale_factor). | |
714 if (max_offset.x()) { | |
715 scroll_offset_dip.set_x((scroll_offset.x() * max_scroll_offset_dip_.x()) / | |
716 max_offset.x()); | |
717 } | |
718 if (max_offset.y()) { | |
719 scroll_offset_dip.set_y((scroll_offset.y() * max_scroll_offset_dip_.y()) / | |
720 max_offset.y()); | |
721 } | |
722 | |
723 DCHECK_LE(0, scroll_offset_dip.x()); | |
724 DCHECK_LE(0, scroll_offset_dip.y()); | |
725 DCHECK_LE(scroll_offset_dip.x(), max_scroll_offset_dip_.x()); | |
726 DCHECK_LE(scroll_offset_dip.y(), max_scroll_offset_dip_.y()); | |
727 | |
728 if (scroll_offset_dip_ == scroll_offset_dip) | |
729 return; | |
730 | |
731 scroll_offset_dip_ = scroll_offset_dip; | |
732 | |
733 if (compositor_) | |
734 compositor_->DidChangeRootLayerScrollOffset(); | |
735 } | |
736 | |
737 void InProcessViewRenderer::DidUpdateContent() { | |
738 TRACE_EVENT_INSTANT0("android_webview", | |
739 "InProcessViewRenderer::DidUpdateContent", | |
740 TRACE_EVENT_SCOPE_THREAD); | |
741 clear_view_ = false; | |
742 EnsureContinuousInvalidation(NULL, false); | |
743 if (on_new_picture_enable_) | |
744 client_->OnNewPicture(); | |
745 } | |
746 | |
747 void InProcessViewRenderer::SetMaxRootLayerScrollOffset( | |
748 gfx::Vector2dF new_value_dip) { | |
749 DCHECK_GT(dip_scale_, 0); | |
750 | |
751 max_scroll_offset_dip_ = new_value_dip; | |
752 DCHECK_LE(0, max_scroll_offset_dip_.x()); | |
753 DCHECK_LE(0, max_scroll_offset_dip_.y()); | |
754 | |
755 client_->SetMaxContainerViewScrollOffset(max_scroll_offset()); | |
756 } | |
757 | |
758 void InProcessViewRenderer::SetTotalRootLayerScrollOffset( | |
759 gfx::Vector2dF scroll_offset_dip) { | |
760 // TOOD(mkosiba): Add a DCHECK to say that this does _not_ get called during | |
761 // DrawGl when http://crbug.com/249972 is fixed. | |
762 if (scroll_offset_dip_ == scroll_offset_dip) | |
763 return; | |
764 | |
765 scroll_offset_dip_ = scroll_offset_dip; | |
766 | |
767 gfx::Vector2d max_offset = max_scroll_offset(); | |
768 gfx::Vector2d scroll_offset; | |
769 // For an explanation as to why this is done this way see the comment in | |
770 // InProcessViewRenderer::ScrollTo. | |
771 if (max_scroll_offset_dip_.x()) { | |
772 scroll_offset.set_x((scroll_offset_dip.x() * max_offset.x()) / | |
773 max_scroll_offset_dip_.x()); | |
774 } | |
775 | |
776 if (max_scroll_offset_dip_.y()) { | |
777 scroll_offset.set_y((scroll_offset_dip.y() * max_offset.y()) / | |
778 max_scroll_offset_dip_.y()); | |
779 } | |
780 | |
781 DCHECK(0 <= scroll_offset.x()); | |
782 DCHECK(0 <= scroll_offset.y()); | |
783 // Disabled because the conditions are being violated while running | |
784 // AwZoomTest.testMagnification, see http://crbug.com/340648 | |
785 // DCHECK(scroll_offset.x() <= max_offset.x()); | |
786 // DCHECK(scroll_offset.y() <= max_offset.y()); | |
787 | |
788 client_->ScrollContainerViewTo(scroll_offset); | |
789 } | |
790 | |
791 gfx::Vector2dF InProcessViewRenderer::GetTotalRootLayerScrollOffset() { | |
792 return scroll_offset_dip_; | |
793 } | |
794 | |
795 bool InProcessViewRenderer::IsExternalFlingActive() const { | |
796 return client_->IsFlingActive(); | |
797 } | |
798 | |
799 void InProcessViewRenderer::SetRootLayerPageScaleFactorAndLimits( | |
800 float page_scale_factor, | |
801 float min_page_scale_factor, | |
802 float max_page_scale_factor) { | |
803 page_scale_factor_ = page_scale_factor; | |
804 DCHECK_GT(page_scale_factor_, 0); | |
805 client_->SetPageScaleFactorAndLimits( | |
806 page_scale_factor, min_page_scale_factor, max_page_scale_factor); | |
807 } | |
808 | |
809 void InProcessViewRenderer::SetRootLayerScrollableSize( | |
810 gfx::SizeF scrollable_size) { | |
811 client_->SetContentsSize(scrollable_size); | |
812 } | |
813 | |
814 void InProcessViewRenderer::DidOverscroll( | |
815 gfx::Vector2dF accumulated_overscroll, | |
816 gfx::Vector2dF latest_overscroll_delta, | |
817 gfx::Vector2dF current_fling_velocity) { | |
818 const float physical_pixel_scale = dip_scale_ * page_scale_factor_; | |
819 if (accumulated_overscroll == latest_overscroll_delta) | |
820 overscroll_rounding_error_ = gfx::Vector2dF(); | |
821 gfx::Vector2dF scaled_overscroll_delta = | |
822 gfx::ScaleVector2d(latest_overscroll_delta, physical_pixel_scale); | |
823 gfx::Vector2d rounded_overscroll_delta = gfx::ToRoundedVector2d( | |
824 scaled_overscroll_delta + overscroll_rounding_error_); | |
825 overscroll_rounding_error_ = | |
826 scaled_overscroll_delta - rounded_overscroll_delta; | |
827 client_->DidOverscroll(rounded_overscroll_delta); | |
828 } | |
829 | |
830 void InProcessViewRenderer::EnsureContinuousInvalidation( | |
831 AwDrawGLInfo* draw_info, | |
832 bool invalidate_ignore_compositor) { | |
833 // This method should be called again when any of these conditions change. | |
834 bool need_invalidate = | |
835 compositor_needs_continuous_invalidate_ || invalidate_ignore_compositor; | |
836 if (!need_invalidate || block_invalidates_) | |
837 return; | |
838 | |
839 // Always call view invalidate. We rely the Android framework to ignore the | |
840 // invalidate when it's not needed such as when view is not visible. | |
841 if (draw_info) { | |
842 draw_info->dirty_left = cached_global_visible_rect_.x(); | |
843 draw_info->dirty_top = cached_global_visible_rect_.y(); | |
844 draw_info->dirty_right = cached_global_visible_rect_.right(); | |
845 draw_info->dirty_bottom = cached_global_visible_rect_.bottom(); | |
846 draw_info->status_mask |= AwDrawGLInfo::kStatusMaskDraw; | |
847 } else { | |
848 client_->PostInvalidate(); | |
849 } | |
850 | |
851 // Stop fallback ticks when one of these is true. | |
852 // 1) Webview is paused. Also need to check we are not in clear view since | |
853 // paused, offscreen still expect clear view to recover. | |
854 // 2) If we are attached to window and the window is not visible (eg when | |
855 // app is in the background). We are sure in this case the webview is used | |
856 // "on-screen" but that updates are not needed when in the background. | |
857 bool throttle_fallback_tick = | |
858 (is_paused_ && !clear_view_) || (attached_to_window_ && !window_visible_); | |
859 if (throttle_fallback_tick) | |
860 return; | |
861 | |
862 block_invalidates_ = compositor_needs_continuous_invalidate_; | |
863 | |
864 // Unretained here is safe because the callback is cancelled when | |
865 // |fallback_tick_| is destroyed. | |
866 fallback_tick_.Reset(base::Bind(&InProcessViewRenderer::FallbackTickFired, | |
867 base::Unretained(this))); | |
868 | |
869 // No need to reschedule fallback tick if compositor does not need to be | |
870 // ticked. This can happen if this is reached because | |
871 // invalidate_ignore_compositor is true. | |
872 if (compositor_needs_continuous_invalidate_) { | |
873 BrowserThread::PostDelayedTask( | |
874 BrowserThread::UI, | |
875 FROM_HERE, | |
876 fallback_tick_.callback(), | |
877 base::TimeDelta::FromMilliseconds( | |
878 kFallbackTickTimeoutInMilliseconds)); | |
879 } | |
880 } | |
881 | |
882 void InProcessViewRenderer::FallbackTickFired() { | |
883 TRACE_EVENT1("android_webview", | |
884 "InProcessViewRenderer::FallbackTickFired", | |
885 "compositor_needs_continuous_invalidate_", | |
886 compositor_needs_continuous_invalidate_); | |
887 | |
888 // This should only be called if OnDraw or DrawGL did not come in time, which | |
889 // means block_invalidates_ must still be true. | |
890 DCHECK(block_invalidates_); | |
891 if (compositor_needs_continuous_invalidate_ && compositor_) | |
892 ForceFakeCompositeSW(); | |
893 } | |
894 | |
895 void InProcessViewRenderer::ForceFakeCompositeSW() { | |
896 DCHECK(compositor_); | |
897 SkBitmapDevice device(SkBitmap::kARGB_8888_Config, 1, 1); | |
898 SkCanvas canvas(&device); | |
899 CompositeSW(&canvas); | |
900 } | |
901 | |
902 bool InProcessViewRenderer::CompositeSW(SkCanvas* canvas) { | |
903 DCHECK(compositor_); | |
904 | |
905 fallback_tick_.Cancel(); | |
906 block_invalidates_ = true; | |
907 bool result = compositor_->DemandDrawSw(canvas); | |
908 block_invalidates_ = false; | |
909 EnsureContinuousInvalidation(NULL, false); | |
910 return result; | |
911 } | |
912 | |
913 std::string InProcessViewRenderer::ToString(AwDrawGLInfo* draw_info) const { | |
914 std::string str; | |
915 base::StringAppendF(&str, "is_paused: %d ", is_paused_); | |
916 base::StringAppendF(&str, "view_visible: %d ", view_visible_); | |
917 base::StringAppendF(&str, "window_visible: %d ", window_visible_); | |
918 base::StringAppendF(&str, "dip_scale: %f ", dip_scale_); | |
919 base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_); | |
920 base::StringAppendF(&str, | |
921 "compositor_needs_continuous_invalidate: %d ", | |
922 compositor_needs_continuous_invalidate_); | |
923 base::StringAppendF(&str, "block_invalidates: %d ", block_invalidates_); | |
924 base::StringAppendF(&str, "view width height: [%d %d] ", width_, height_); | |
925 base::StringAppendF(&str, "attached_to_window: %d ", attached_to_window_); | |
926 base::StringAppendF(&str, "hardware_initialized: %d ", hardware_initialized_); | |
927 base::StringAppendF(&str, "hardware_failed: %d ", hardware_failed_); | |
928 base::StringAppendF(&str, | |
929 "global visible rect: %s ", | |
930 cached_global_visible_rect_.ToString().c_str()); | |
931 base::StringAppendF(&str, | |
932 "scroll_at_start_of_frame: %s ", | |
933 scroll_at_start_of_frame_.ToString().c_str()); | |
934 base::StringAppendF( | |
935 &str, "scroll_offset_dip: %s ", scroll_offset_dip_.ToString().c_str()); | |
936 base::StringAppendF(&str, | |
937 "overscroll_rounding_error_: %s ", | |
938 overscroll_rounding_error_.ToString().c_str()); | |
939 base::StringAppendF( | |
940 &str, "on_new_picture_enable: %d ", on_new_picture_enable_); | |
941 base::StringAppendF(&str, "clear_view: %d ", clear_view_); | |
942 if (draw_info) { | |
943 base::StringAppendF(&str, | |
944 "clip left top right bottom: [%d %d %d %d] ", | |
945 draw_info->clip_left, | |
946 draw_info->clip_top, | |
947 draw_info->clip_right, | |
948 draw_info->clip_bottom); | |
949 base::StringAppendF(&str, | |
950 "surface width height: [%d %d] ", | |
951 draw_info->width, | |
952 draw_info->height); | |
953 base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer); | |
954 } | |
955 return str; | |
956 } | |
957 | 325 |
958 } // namespace android_webview | 326 } // namespace android_webview |
OLD | NEW |