New Compositor and tab content

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 214 matching lines @@
         overlay_candidate_validator_(
             new display_compositor::
                 CompositorOverlayCandidateValidatorAndroid()) {
     capabilities_.adjust_deadline_for_parent = false;
     capabilities_.max_frames_pending = kMaxDisplaySwapBuffers;
   }
 
   ~OutputSurfaceWithoutParent() override = default;
 
   void SwapBuffers(cc::CompositorFrame frame) override {
+    LOG(ERROR) << "bshe "
+               << "===out put surface with parent swap buffers";
     GetCommandBufferProxy()->SetLatencyInfo(frame.metadata.latency_info);
     if (frame.gl_frame_data->sub_buffer_rect.IsEmpty()) {
       context_provider_->ContextSupport()->CommitOverlayPlanes();
     } else {
       DCHECK(frame.gl_frame_data->sub_buffer_rect ==
              gfx::Rect(frame.gl_frame_data->size));
       context_provider_->ContextSupport()->Swap();
     }
   }
 
@@ skipping 151 matching lines @@
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       output_surface_request_pending_(false),
       needs_begin_frames_(false),
       weak_factory_(this) {
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
       ->RegisterSurfaceClientId(surface_id_allocator_->client_id());
   DCHECK(client);
   DCHECK(root_window);
-  DCHECK(root_window->GetLayer() == nullptr);
+  // DCHECK(root_window->GetLayer() == nullptr);
   root_window->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);
   CreateLayerTreeHost();
   resource_manager_.Init(host_.get());
 }
 
 CompositorImpl::~CompositorImpl() {
@@ skipping 13 matching lines @@
 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()) {
+    LOG(ERROR) << "bshe "
+               << "set root layer success====";
     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();
 
+  LOG(ERROR) << "bshe "
+             << "expect set Surface correctly====";
   if (window_) {
     // Shut down GL context before unregistering surface.
     SetVisible(false);
     tracker->RemoveSurface(surface_handle_);
     ANativeWindow_release(window_);
     window_ = NULL;
     UnregisterViewSurface(surface_handle_);
     surface_handle_ = gpu::kNullSurfaceHandle;
   }
 
   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) {
     window_ = window;
     ANativeWindow_acquire(window);
     surface_handle_ = tracker->AddSurfaceForNativeWidget(window);
     // Register first, SetVisible() might create an OutputSurface.
     RegisterViewSurface(surface_handle_, j_surface.obj());
     SetVisible(true);
+    LOG(ERROR) << "bshe "
+               << "set Surface correctly====";
     ANativeWindow_release(window);
   }
 }
 
 void CompositorImpl::CreateLayerTreeHost() {
   DCHECK(!host_);
 
   cc::LayerTreeSettings settings;
   settings.renderer_settings.refresh_rate = 60.0;
   settings.renderer_settings.allow_antialiasing = false;
@@ skipping 252 matching lines @@
 void CompositorImpl::DidPostSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidPostSwapBuffers");
   pending_swapbuffers_++;
 }
 
 void CompositorImpl::DidCompleteSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidCompleteSwapBuffers");
   DCHECK_GT(pending_swapbuffers_, 0U);
   pending_swapbuffers_--;
   client_->OnSwapBuffersCompleted(pending_swapbuffers_);
+  LOG(ERROR) << "bshe===="
+             << "swap buffer complelet";
 }
 
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
   // This really gets called only once from
   // SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() when the
   // context was lost.
   if (host_->visible())
     host_->SetNeedsCommit();
   client_->OnSwapBuffersCompleted(0);
@@ skipping 36 matching lines @@
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content