webview: Initialize synchronous compositor after first activation.

content/browser/android/in_process/synchronous_compositor_impl.cc

 // Copyright 2013 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/android/in_process/synchronous_compositor_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 56 matching lines @@
   return FromID(GetInProcessRendererId(), routing_id);
 }
 
 SynchronousCompositorImpl::SynchronousCompositorImpl(WebContents* contents)
     : compositor_client_(NULL),
       output_surface_(NULL),
       begin_frame_source_(nullptr),
       contents_(contents),
       routing_id_(contents->GetRoutingID()),
       input_handler_(NULL),
+      has_initialized_(false),
       is_active_(false),
       renderer_needs_begin_frames_(false),
       weak_ptr_factory_(this) {
   DCHECK(contents);
   DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
 }
 
 SynchronousCompositorImpl::~SynchronousCompositorImpl() {
   DCHECK(!output_surface_);
   DCHECK(!begin_frame_source_);
@@ skipping 46 matching lines @@
   output_surface_ = output_surface;
   begin_frame_source_ = begin_frame_source;
 
   begin_frame_source_->SetCompositor(this);
   output_surface_->SetCompositor(this);
 
   output_surface_->SetTreeActivationCallback(
       base::Bind(&SynchronousCompositorImpl::DidActivatePendingTree,
                  weak_ptr_factory_.GetWeakPtr()));
 
+  SetInputHandler(input_handler);
+
   OnNeedsBeginFramesChange(begin_frame_source_->NeedsBeginFrames());
-
-  compositor_client_->DidInitializeCompositor(this);
-
-  SetInputHandler(input_handler);
 }
 
 void SynchronousCompositorImpl::DidDestroyRendererObjects() {
   DCHECK(output_surface_);
   DCHECK(begin_frame_source_);
   DCHECK(compositor_client_);
 
+  OnNeedsBeginFramesChange(false);
+
   begin_frame_source_->SetCompositor(nullptr);
   output_surface_->SetCompositor(nullptr);
   SetInputHandler(nullptr);
   compositor_client_->DidDestroyCompositor(this);

[boliu, 2015/05/29 23:21:12]

Every single compositor_client_ call needs to be guarded by has_initialized_
now. DidInitializeCompositor must be the first call into compositor_client_ or
bad things may happen. Seems large change, but this really is the right place to
handle this.

Not too long ago, there were null checks. You can do the same thing as the old
null behavior when has_initialized_ is false:
https://codereview.chromium.org/1127943002/

   output_surface_ = nullptr;
   begin_frame_source_ = nullptr;
 }
 
 scoped_ptr<cc::CompositorFrame> SynchronousCompositorImpl::DemandDrawHw(
     gfx::Size surface_size,
     const gfx::Transform& transform,
     gfx::Rect viewport,
     gfx::Rect clip,
     gfx::Rect viewport_rect_for_tile_priority,
@@ skipping 87 matching lines @@
 
 void SynchronousCompositorImpl::BeginFrame(const cc::BeginFrameArgs& args) {
   if (begin_frame_source_)
     begin_frame_source_->BeginFrame(args);
 }
 
 void SynchronousCompositorImpl::UpdateNeedsBeginFrames() {
   RenderWidgetHostViewAndroid* rwhv = static_cast<RenderWidgetHostViewAndroid*>(
       contents_->GetRenderWidgetHostView());
   if (rwhv)
-    rwhv->OnSetNeedsBeginFrames(is_active_ && renderer_needs_begin_frames_);
+    rwhv->OnSetNeedsBeginFrames((is_active_ || !has_initialized_) &&
+                                renderer_needs_begin_frames_);
 }
 
 void SynchronousCompositorImpl::SetInputHandler(
     cc::InputHandler* input_handler) {
   DCHECK(CalledOnValidThread());
 
   if (input_handler_)
     input_handler_->SetRootLayerScrollOffsetDelegate(NULL);
 
   input_handler_ = input_handler;
@@ skipping 31 matching lines @@
   RenderProcessHost* rph = contents_->GetRenderProcessHost();
   for (ScopedVector<IPC::Message>::const_iterator i = messages.begin();
        i != messages.end();
        ++i) {
     rph->OnMessageReceived(**i);
   }
 }
 
 void SynchronousCompositorImpl::DidActivatePendingTree() {
   DCHECK(compositor_client_);
+  if (!has_initialized_) {
+    has_initialized_ = true;
+    compositor_client_->DidInitializeCompositor(this);
+  }
   compositor_client_->DidUpdateContent();
   DeliverMessages();
 }
 
 gfx::ScrollOffset SynchronousCompositorImpl::GetTotalScrollOffset() {
   DCHECK(CalledOnValidThread());
   DCHECK(compositor_client_);
   // TODO(miletus): Make GetTotalRootLayerScrollOffset return
   // ScrollOffset. crbug.com/414283.
   return gfx::ScrollOffset(
@@ skipping 41 matching lines @@
     g_factory.Get();  // Ensure it's initialized.
     SynchronousCompositorImpl::CreateForWebContents(contents);
   }
   SynchronousCompositorImpl* instance =
       SynchronousCompositorImpl::FromWebContents(contents);
   DCHECK(instance);
   instance->SetClient(client);
 }
 
 }  // namespace content