Introduce ViewRoot forwarding input/view events to native

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 <stdint.h>
 #include <unordered_set>
@@ skipping 47 matching lines @@
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "gpu/ipc/common/gpu_surface_tracker.h"
 #include "gpu/vulkan/vulkan_surface.h"
 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.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/android/view_root.h"
 #include "ui/android/window_android.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/swap_result.h"
 
 namespace gpu {
 struct GpuProcessHostedCALayerTreeParamsMac;
 }
 
 namespace content {
 
 namespace {
 
 const unsigned int kMaxDisplaySwapBuffers = 1U;
 
 gpu::SharedMemoryLimits GetCompositorContextSharedMemoryLimits(
     gfx::NativeWindow window) {
   constexpr size_t kBytesPerPixel = 4;
   const gfx::Size size = display::Screen::GetScreen()
-                             ->GetDisplayNearestWindow(window)
+                             ->GetDisplayNearestWindowAndroid(window)
                              .GetSizeInPixel();
   const size_t full_screen_texture_size_in_bytes =
       size.width() * size.height() * kBytesPerPixel;
 
   gpu::SharedMemoryLimits limits;
   // This limit is meant to hold the contents of the display compositor
   // drawing the scene. See discussion here:
   // https://codereview.chromium.org/1900993002/diff/90001/content/browser/renderer_host/compositor_impl_android.cc?context=3&column_width=80&tab_spaces=8
   limits.command_buffer_size = 64 * 1024;
   // These limits are meant to hold the uploads for the browser UI without
@@ skipping 204 matching lines @@
   }
 };
 
 base::LazyInstance<SingleThreadTaskGraphRunner> g_task_graph_runner =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // anonymous namespace
 
 // static
 Compositor* Compositor::Create(CompositorClient* client,
-                               gfx::NativeWindow root_window) {
-  return client ? new CompositorImpl(client, root_window) : NULL;
+                               ui::ViewRoot* view_root) {
+  return client ? new CompositorImpl(client, view_root) : NULL;
 }
 
 // static
 void Compositor::Initialize() {
   DCHECK(!CompositorImpl::IsInitialized());
   g_initialized = true;
 }
 
 // static
 bool CompositorImpl::IsInitialized() {
   return g_initialized;
 }
 
 CompositorImpl::CompositorImpl(CompositorClient* client,
-                               gfx::NativeWindow root_window)
+                               ui::ViewRoot* view_root)
     : frame_sink_id_(
           ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId()),
-      resource_manager_(root_window),
+      resource_manager_(view_root->GetWindowAndroid()),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
-      root_window_(root_window),
+      root_window_(view_root->GetWindowAndroid()),
+      view_root_(view_root),
       needs_animate_(false),
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       compositor_frame_sink_request_pending_(false),
       weak_factory_(this) {
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
       ->RegisterFrameSinkId(frame_sink_id_);
   DCHECK(client);
-  DCHECK(root_window);
-  DCHECK(root_window->GetLayer() == nullptr);
-  root_window->SetLayer(cc::Layer::Create());
+  DCHECK(view_root);
+  DCHECK(view_root->GetLayer() == nullptr);
+  view_root->SetLayer(cc::Layer::Create());
   readback_layer_tree_ = cc::Layer::Create();
   readback_layer_tree_->SetHideLayerAndSubtree(true);
-  root_window->GetLayer()->AddChild(readback_layer_tree_);
-  root_window->AttachCompositor(this);
+  view_root->GetLayer()->AddChild(readback_layer_tree_);
+  root_window_->AttachCompositor(this);
   CreateLayerTreeHost();
   resource_manager_.Init(host_->GetUIResourceManager());
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
-  root_window_->SetLayer(nullptr);
+  view_root_->SetLayer(nullptr);
   // Clean-up any surface references.
   SetSurface(NULL);
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
       ->InvalidateFrameSinkId(frame_sink_id_);
 }
 
 ui::UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
   return *this;
 }
 
 ui::ResourceManager& CompositorImpl::GetResourceManager() {
   return resource_manager_;
 }
 
 void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
   if (subroot_layer_.get()) {
     subroot_layer_->RemoveFromParent();
     subroot_layer_ = NULL;
   }
-  if (root_window_->GetLayer()) {
-    subroot_layer_ = root_window_->GetLayer();
-    root_window_->GetLayer()->AddChild(root_layer);
+  if (view_root_->GetLayer()) {
+    subroot_layer_ = view_root_->GetLayer();
+    view_root_->GetLayer()->AddChild(root_layer);
   }
 }
 
 void CompositorImpl::SetSurface(jobject surface) {
   JNIEnv* env = base::android::AttachCurrentThread();
   gpu::GpuSurfaceTracker* tracker = gpu::GpuSurfaceTracker::Get();
 
   if (window_) {
     // Shut down GL context before unregistering surface.
     SetVisible(false);
@@ skipping 44 matching lines @@
   animation_host_ = cc::AnimationHost::CreateMainInstance();
 
   cc::LayerTreeHostInProcess::InitParams params;
   params.client = this;
   params.task_graph_runner = g_task_graph_runner.Pointer();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.settings = &settings;
   params.mutator_host = animation_host_.get();
   host_ = cc::LayerTreeHostInProcess::CreateSingleThreaded(this, &params);
   DCHECK(!host_->IsVisible());
-  host_->GetLayerTree()->SetRootLayer(root_window_->GetLayer());
+  host_->GetLayerTree()->SetRootLayer(view_root_->GetLayer());
   host_->SetFrameSinkId(frame_sink_id_);
   host_->GetLayerTree()->SetViewportSize(size_);
   SetHasTransparentBackground(false);
   host_->GetLayerTree()->SetDeviceScaleFactor(1);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::SetVisible(bool visible) {
@@ skipping 20 matching lines @@
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
     return;
 
   size_ = size;
   if (host_)
     host_->GetLayerTree()->SetViewportSize(size);
   if (display_)
     display_->Resize(size);
-  root_window_->GetLayer()->SetBounds(size);
+  view_root_->GetLayer()->SetBounds(size);
 }
 
 void CompositorImpl::SetHasTransparentBackground(bool transparent) {
   has_transparent_background_ = transparent;
   if (host_) {
     host_->GetLayerTree()->set_has_transparent_background(transparent);
 
     // Give a delay in setting the background color to avoid the color for
     // the normal mode (white) affecting the UI transition.
     base::ThreadTaskRunnerHandle::Get().get()->PostDelayedTask(
@@ skipping 214 matching lines @@
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   readback_layer_tree_->AddChild(layer);
 }
 
 void CompositorImpl::RequestCopyOfOutputOnRootLayer(
     std::unique_ptr<cc::CopyOutputRequest> request) {
-  root_window_->GetLayer()->RequestCopyOfOutput(std::move(request));
+  view_root_->GetLayer()->RequestCopyOfOutput(std::move(request));
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->IsVisible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 cc::FrameSinkId CompositorImpl::GetFrameSinkId() {
   return frame_sink_id_;
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content