Make WindowAndroid a ViewAndroid

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 347 matching lines @@
         g_shared_vulkan_context_provider_android_.Pointer();
     if (!*context_provider)
       *context_provider = cc::VulkanInProcessContextProvider::Create();
     return *context_provider;
   }
   return nullptr;
 }
 
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
-    : root_layer_(cc::Layer::Create()),
-      surface_id_allocator_(CreateSurfaceIdAllocator()),
+    : surface_id_allocator_(CreateSurfaceIdAllocator()),
       resource_manager_(root_window),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
       root_window_(root_window),
       needs_animate_(false),
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       output_surface_request_pending_(false),
       needs_begin_frames_(false),
       weak_factory_(this) {
   DCHECK(client);
   DCHECK(root_window);
+  root_window->SetLayer(cc::Layer::Create());
   root_window->AttachCompositor(this);
   CreateLayerTreeHost();
   resource_manager_.Init(host_.get());
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
+  root_window_->SetLayer(nullptr);
   // Clean-up any surface references.
   SetSurface(NULL);
 }
 
 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_layer.get()) {
-    subroot_layer_ = root_layer;
-    root_layer_->AddChild(root_layer);
+  if (root_window_->GetLayer()) {
+    subroot_layer_ = root_window_->GetLayer();
+    root_window_->GetLayer()->AddChild(root_layer);
   }
 }
 
 void CompositorImpl::SetSurface(jobject surface) {
   JNIEnv* env = base::android::AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> j_surface(env, surface);
 
   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 
   if (window_) {
@@ skipping 45 matching lines @@
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = HostSharedBitmapManager::current();
   params.gpu_memory_buffer_manager = BrowserGpuMemoryBufferManager::current();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.settings = &settings;
   params.animation_host = cc::AnimationHost::CreateMainInstance();
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
   DCHECK(!host_->visible());
-  host_->SetRootLayer(root_layer_);
+  host_->SetRootLayer(root_window_->GetLayer());
   host_->set_surface_id_namespace(surface_id_allocator_->id_namespace());
   host_->SetViewportSize(size_);
   host_->set_has_transparent_background(has_transparent_background_);
   host_->SetDeviceScaleFactor(device_scale_factor_);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::SetVisible(bool visible) {
@@ skipping 21 matching lines @@
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
     return;
 
   size_ = size;
   if (host_)
     host_->SetViewportSize(size);
   if (display_)
     display_->Resize(size);
-  root_layer_->SetBounds(size);
+  root_window_->GetLayer()->SetBounds(size);
 }
 
 void CompositorImpl::SetHasTransparentBackground(bool flag) {
   has_transparent_background_ = flag;
   if (host_)
     host_->set_has_transparent_background(flag);
 }
 
 void CompositorImpl::SetNeedsComposite() {
   if (!host_->visible())
@@ skipping 243 matching lines @@
     host_->SetNeedsCommit();
   client_->OnSwapBuffersCompleted(0);
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::RequestCopyOfOutputOnRootLayer(
     std::unique_ptr<cc::CopyOutputRequest> request) {
-  root_layer_->RequestCopyOfOutput(std::move(request));
+  root_window_->GetLayer()->RequestCopyOfOutput(std::move(request));
 }
 
 void CompositorImpl::OnVSync(base::TimeTicks frame_time,
                              base::TimeDelta vsync_period) {
   FOR_EACH_OBSERVER(VSyncObserver, observer_list_,
                     OnVSync(frame_time, vsync_period));
   if (needs_begin_frames_)
     root_window_->RequestVSyncUpdate();
 }
 
 void CompositorImpl::OnNeedsBeginFramesChange(bool needs_begin_frames) {
   if (needs_begin_frames_ == needs_begin_frames)
     return;
 
   needs_begin_frames_ = needs_begin_frames;
   if (needs_begin_frames_)
     root_window_->RequestVSyncUpdate();
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content