Remove GpuHostMsg_FrameDrawn and replace with client channel swap ack

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
+#include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/browser/android/child_process_launcher_android.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/public/browser/android/compositor_client.h"
+#include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "ui/base/android/window_android.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/android/surface_texture_tracker.h"
 #include "webkit/common/gpu/context_provider_in_process.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
+namespace content {
+
 namespace {
 
 const unsigned int kMaxSwapBuffers = 2U;
 
 // Used to override capabilities_.adjust_deadline_for_parent to false
 class OutputSurfaceWithoutParent : public cc::OutputSurface {
  public:
-  OutputSurfaceWithoutParent(const scoped_refptr<
-      content::ContextProviderCommandBuffer>& context_provider,
-      base::WeakPtr<content::CompositorImpl> compositor_impl)
-      : cc::OutputSurface(context_provider) {
+  OutputSurfaceWithoutParent(
+      const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
+      base::WeakPtr<CompositorImpl> compositor_impl)
+      : cc::OutputSurface(context_provider),
+        swap_buffers_completion_callback_(
+            base::Bind(&OutputSurfaceWithoutParent::OnSwapBuffersCompleted,
+                       base::Unretained(this))) {
     capabilities_.adjust_deadline_for_parent = false;
     compositor_impl_ = compositor_impl;
     main_thread_ = base::MessageLoopProxy::current();
   }
 
   virtual void SwapBuffers(cc::CompositorFrame* frame) override {
     for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
       frame->metadata.latency_info[i].AddLatencyNumber(
           ui::INPUT_EVENT_BROWSER_SWAP_BUFFER_COMPONENT, 0, 0);
     }
 
-    content::ContextProviderCommandBuffer* provider_command_buffer =
-        static_cast<content::ContextProviderCommandBuffer*>(
-            context_provider_.get());
-    content::CommandBufferProxyImpl* command_buffer_proxy =
-        provider_command_buffer->GetCommandBufferProxy();
-    DCHECK(command_buffer_proxy);
-    command_buffer_proxy->SetLatencyInfo(frame->metadata.latency_info);
-
-    OutputSurface::SwapBuffers(frame);
+    GetCommandBufferProxy()->SetLatencyInfo(frame->metadata.latency_info);
+    DCHECK(frame->gl_frame_data->sub_buffer_rect ==
+           gfx::Rect(frame->gl_frame_data->size));
+    context_provider_->ContextSupport()->Swap();
   }
 
   virtual bool BindToClient(cc::OutputSurfaceClient* client) override {
     if (!OutputSurface::BindToClient(client))
       return false;
 
+    GetCommandBufferProxy()->SetSwapBuffersCompletionCallback(
+        swap_buffers_completion_callback_.callback());
+
     main_thread_->PostTask(
         FROM_HERE,
-        base::Bind(&content::CompositorImpl::PopulateGpuCapabilities,
+        base::Bind(&CompositorImpl::PopulateGpuCapabilities,
                    compositor_impl_,
                    context_provider_->ContextCapabilities().gpu));
 
     return true;
   }
 
+ private:
+  CommandBufferProxyImpl* GetCommandBufferProxy() {
+    ContextProviderCommandBuffer* provider_command_buffer =
+        static_cast<content::ContextProviderCommandBuffer*>(
+            context_provider_.get());
+    CommandBufferProxyImpl* command_buffer_proxy =
+        provider_command_buffer->GetCommandBufferProxy();
+    DCHECK(command_buffer_proxy);
+    return command_buffer_proxy;
+  }
+
+  void OnSwapBuffersCompleted(
+      const std::vector<ui::LatencyInfo>& latency_info) {
+    RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
+    OutputSurface::OnSwapBuffersComplete();
+  }
+
+  base::CancelableCallback<void(const std::vector<ui::LatencyInfo>&)>
+      swap_buffers_completion_callback_;
+
   scoped_refptr<base::MessageLoopProxy> main_thread_;
-  base::WeakPtr<content::CompositorImpl> compositor_impl_;
+  base::WeakPtr<CompositorImpl> compositor_impl_;
 };
 
 class SurfaceTextureTrackerImpl : public gfx::SurfaceTextureTracker {
  public:
   SurfaceTextureTrackerImpl() : next_surface_texture_id_(1) {
     thread_checker_.DetachFromThread();
   }
 
   // Overridden from gfx::SurfaceTextureTracker:
   virtual scoped_refptr<gfx::SurfaceTexture> AcquireSurfaceTexture(
@@ skipping 13 matching lines @@
                         int child_process_id) {
     DCHECK(thread_checker_.CalledOnValidThread());
     int surface_texture_id = next_surface_texture_id_++;
     if (next_surface_texture_id_ == INT_MAX)
       next_surface_texture_id_ = 1;
 
     base::AutoLock lock(surface_textures_lock_);
     SurfaceTextureMapKey key(surface_texture_id, child_process_id);
     DCHECK(surface_textures_.find(key) == surface_textures_.end());
     surface_textures_[key] = surface_texture;
-    content::RegisterChildProcessSurfaceTexture(
+    RegisterChildProcessSurfaceTexture(
         surface_texture_id,
         child_process_id,
         surface_texture->j_surface_texture().obj());
     return surface_texture_id;
   }
 
   void RemoveAllSurfaceTextures(int child_process_id) {
     DCHECK(thread_checker_.CalledOnValidThread());
     base::AutoLock lock(surface_textures_lock_);
     SurfaceTextureMap::iterator it = surface_textures_.begin();
     while (it != surface_textures_.end()) {
       if (it->first.second == child_process_id) {
-        content::UnregisterChildProcessSurfaceTexture(it->first.first,
-                                                      it->first.second);
+        UnregisterChildProcessSurfaceTexture(it->first.first, it->first.second);
         surface_textures_.erase(it++);
       } else {
         ++it;
       }
     }
   }
 
  private:
   typedef std::pair<int, int> SurfaceTextureMapKey;
   typedef base::hash_map<SurfaceTextureMapKey,
                          scoped_refptr<gfx::SurfaceTexture> >
       SurfaceTextureMap;
   SurfaceTextureMap surface_textures_;
   mutable base::Lock surface_textures_lock_;
   int next_surface_texture_id_;
   base::ThreadChecker thread_checker_;
 };
 base::LazyInstance<SurfaceTextureTrackerImpl> g_surface_texture_tracker =
     LAZY_INSTANCE_INITIALIZER;
 
 static bool g_initialized = false;
 
 } // anonymous namespace
 
-namespace content {
-
 // static
 Compositor* Compositor::Create(CompositorClient* client,
                                gfx::NativeWindow root_window) {
   return client ? new CompositorImpl(client, root_window) : NULL;
 }
 
 // static
 void Compositor::Initialize() {
   DCHECK(!CompositorImpl::IsInitialized());
   // SurfaceTextureTracker instance must be set before we create a GPU thread
@@ skipping 211 matching lines @@
     SetVisible(true);
   }
 }
 
 void CompositorImpl::SetSurface(jobject surface) {
   JNIEnv* env = base::android::AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> j_surface(env, surface);
 
   // First, cleanup any existing surface references.
   if (surface_id_)
-    content::UnregisterViewSurface(surface_id_);
+    UnregisterViewSurface(surface_id_);
   SetWindowSurface(NULL);
 
   // Now, set the new surface if we have one.
   ANativeWindow* window = NULL;
   if (surface) {
     // Note: This ensures that any local references used by
     // ANativeWindow_fromSurface are released immediately. This is needed as a
     // workaround for https://code.google.com/p/android/issues/detail?id=68174
     base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
     window = ANativeWindow_fromSurface(env, surface);
   }
   if (window) {
     SetWindowSurface(window);
     ANativeWindow_release(window);
-    content::RegisterViewSurface(surface_id_, j_surface.obj());
+    RegisterViewSurface(surface_id_, j_surface.obj());
   }
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   if (!visible) {
     DCHECK(host_);
     // Look for any layers that were attached to the root for readback
     // and are waiting for Composite() to happen.
     bool readback_pending = false;
     for (size_t i = 0; i < root_layer_->children().size(); ++i) {
@@ skipping 256 matching lines @@
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   if (!host_)
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content