Android Webview IPC-based sync compositing

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 141 matching lines @@
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_ANDROID)
 #include <cpu-features.h>
+#include "content/renderer/android/synchronous_compositor_external_begin_frame_source.h"
 #include "content/renderer/android/synchronous_compositor_factory.h"
+#include "content/renderer/android/synchronous_compositor_filter.h"
 #include "content/renderer/media/android/renderer_demuxer_android.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "content/renderer/theme_helper_mac.h"
 #include "content/renderer/webscrollbarbehavior_impl_mac.h"
 #endif
 
 #if defined(OS_POSIX)
@@ skipping 679 matching lines @@
 
   // Shutdown the file thread if it's running.
   if (file_thread_)
     file_thread_->Stop();
 
   if (compositor_message_filter_.get()) {
     RemoveFilter(compositor_message_filter_.get());
     compositor_message_filter_ = NULL;
   }
 
+#if defined(OS_ANDROID)
+  if (sync_compositor_message_filter_) {
+    RemoveFilter(sync_compositor_message_filter_.get());
+    sync_compositor_message_filter_ = nullptr;
+  }
+#endif
+
   media_thread_.reset();
 
   compositor_thread_.reset();
 
   // AudioMessageFilter may be accessed on |media_thread_|, so shutdown after.
   RemoveFilter(audio_message_filter_.get());
   audio_message_filter_ = NULL;
 
   raster_worker_pool_->Shutdown();
 
@@ skipping 252 matching lines @@
 
   main_input_callback_.Reset(
       base::Bind(base::IgnoreResult(&RenderThreadImpl::OnMessageReceived),
                  base::Unretained(this)));
 
   SetResourceDispatchTaskQueue(renderer_scheduler_->LoadingTaskRunner());
 
   bool enable = !command_line.HasSwitch(switches::kDisableThreadedCompositing);
   if (enable) {
 #if defined(OS_ANDROID)
-    if (SynchronousCompositorFactory* factory =
-        SynchronousCompositorFactory::GetInstance())
-      compositor_task_runner_ = factory->GetCompositorTaskRunner();
+    SynchronousCompositorFactory* sync_compositor_factory =
+        SynchronousCompositorFactory::GetInstance();
+    bool using_ipc_sync_compositing =
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kIPCSyncCompositing);
+    DCHECK(!sync_compositor_factory || !using_ipc_sync_compositing);
+
+    if (sync_compositor_factory) {
+      compositor_task_runner_ =
+          sync_compositor_factory->GetCompositorTaskRunner();
+    }
 #endif
-    if (!compositor_task_runner_.get()) {
+    if (!compositor_task_runner_) {
       compositor_thread_.reset(new base::Thread("Compositor"));
       base::Thread::Options compositor_thread_options;
 #if defined(OS_ANDROID)
       compositor_thread_options.priority = base::ThreadPriority::DISPLAY;
 #endif
       compositor_thread_->StartWithOptions(compositor_thread_options);
       compositor_task_runner_ = compositor_thread_->task_runner();
       compositor_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(base::IgnoreResult(&ThreadRestrictions::SetIOAllowed),
                      false));
     }
 
     InputHandlerManagerClient* input_handler_manager_client = NULL;
 #if defined(OS_ANDROID)
-    if (SynchronousCompositorFactory* factory =
-        SynchronousCompositorFactory::GetInstance()) {
-      input_handler_manager_client = factory->GetInputHandlerManagerClient();
+    if (using_ipc_sync_compositing) {
+      sync_compositor_message_filter_ =
+          new SynchronousCompositorFilter(compositor_task_runner_);
+      AddFilter(sync_compositor_message_filter_.get());
+      input_handler_manager_client = sync_compositor_message_filter_.get();
+    } else if (sync_compositor_factory) {
+      input_handler_manager_client =
+          sync_compositor_factory->GetInputHandlerManagerClient();
     }
 #endif
     if (!input_handler_manager_client) {
       scoped_refptr<InputEventFilter> compositor_input_event_filter(
           new InputEventFilter(main_input_callback_.callback(),
                                main_thread_compositor_task_runner_,
                                compositor_task_runner_));
       input_handler_manager_client = compositor_input_event_filter.get();
       input_event_filter_ = compositor_input_event_filter;
     }
@@ skipping 370 matching lines @@
 
 cc::ContextProvider* RenderThreadImpl::GetSharedMainThreadContextProvider() {
   return SharedMainThreadContextProvider().get();
 }
 
 scoped_ptr<cc::BeginFrameSource>
 RenderThreadImpl::CreateExternalBeginFrameSource(int routing_id) {
 #if defined(OS_ANDROID)
   if (SynchronousCompositorFactory* factory =
           SynchronousCompositorFactory::GetInstance()) {
+    DCHECK(!sync_compositor_message_filter_);
     return factory->CreateExternalBeginFrameSource(routing_id);
+  } else if (sync_compositor_message_filter_) {
+    return make_scoped_ptr(new SynchronousCompositorExternalBeginFrameSource(
+        routing_id, sync_compositor_message_filter_.get()));
   }
 #endif
   return make_scoped_ptr(new CompositorExternalBeginFrameSource(
       compositor_message_filter_.get(), sync_message_filter(), routing_id));
 }
 
 cc::TaskGraphRunner* RenderThreadImpl::GetTaskGraphRunner() {
   return raster_worker_pool_->GetTaskGraphRunner();
 }
 
@@ skipping 450 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content