UI Resource Manager

cc/trees/thread_proxy.cc

 // Copyright 2011 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.
 
 #include "cc/trees/thread_proxy.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 1427 matching lines @@
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 }
 
+void ThreadProxy::CreateUIResource(UIResourceId uid,

[aelias_OOO_until_Jul13, 2013/07/08 23:40:49]

Let's avoid adding these functions by buffering until commit.  You can imitate
how PageScaleAnimations are handled.

[powei, 2013/07/10 17:47:21]

Requests on the main thread can be buffered until commit, but what about
notifications from the impl-side to the main thread.  Can they be buffered?  Or
do they need to go through thread proxy?

+                                   scoped_refptr<UIResourceBitmap> bitmap,
+                                   bool async) {
+  DCHECK(IsMainThread());
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::CreateUIResourceOnImplThread,
+                 impl_thread_weak_ptr_,
+                 uid,
+                 bitmap,
+                 async));
+}
+
+void ThreadProxy::CreateUIResourceOnImplThread(UIResourceId uid,
+                                          scoped_refptr<UIResourceBitmap>
+                                               bitmap,
+                                          bool async) {
+  DCHECK(IsImplThread());
+  layer_tree_host_impl_->CreateUIResource(uid, bitmap, async);
+}
+
+void ThreadProxy::DeleteUIResource(UIResourceId uid) {
+  DCHECK(IsMainThread());
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::DeleteUIResourceOnImplThread,
+                 impl_thread_weak_ptr_,
+                 uid));
+}
+
+void ThreadProxy::DeleteUIResourceOnImplThread(UIResourceId uid) {
+  DCHECK(IsImplThread());
+  layer_tree_host_impl_->DeleteUIResource(uid);
+}
+
+void ThreadProxy::UIResourceCreatedOnImplThread(UIResourceId uid) {
+  DCHECK(IsImplThread());
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::PostUIResourceCreatedToMainThread,
+                 main_thread_weak_ptr_,
+                 uid));
+  // force a redraw here.  Pretty sure this is incorrect
+  //  scheduler_on_impl_thread_->SetNeedsForcedRedraw();
+}
+
+void ThreadProxy::UIResourceLostOnImplThread(UIResourceId uid) {
+  DCHECK(IsImplThread());
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::PostUIResourceLostToMainThread,
+                 main_thread_weak_ptr_,
+                 uid));
+}
+
+void ThreadProxy::PostUIResourceCreatedToMainThread(UIResourceId uid) {
+  DCHECK(IsMainThread());
+  layer_tree_host_->UIResourceReady(uid);
+}
+
+void ThreadProxy::PostUIResourceLostToMainThread(UIResourceId uid) {
+  DCHECK(IsMainThread());
+  layer_tree_host_->UIResourceLost(uid);
+}
+
 }  // namespace cc