Android WebView: Always send memory policy from Browser to Renderer.

content/renderer/android/synchronous_compositor_output_surface.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/renderer/android/synchronous_compositor_output_surface.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
@@ skipping 88 matching lines @@
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {}
 
 void SynchronousCompositorOutputSurface::SetSyncClient(
     SynchronousCompositorOutputSurfaceClient* compositor) {
   DCHECK(CalledOnValidThread());
   sync_client_ = compositor;
+  Send(new SyncCompositorHostMsg_OutputSurfaceCreated(routing_id_));

[boliu, 2016/06/04 00:47:01]

only do this if sync_client_ is not null

 }
 
 bool SynchronousCompositorOutputSurface::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorOutputSurface, message)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetMemoryPolicy, SetMemoryPolicy)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_ReclaimResources, OnReclaimResources)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
 
   client_->SetMemoryPolicy(memory_policy_);
   client_->SetTreeActivationCallback(
       base::Bind(&SynchronousCompositorOutputSurface::DidActivatePendingTree,
                  base::Unretained(this)));
   registry_->RegisterOutputSurface(routing_id_, this);
   registered_ = true;
-  Send(new SyncCompositorHostMsg_OutputSurfaceCreated(routing_id_));
   return true;
 }
 
 void SynchronousCompositorOutputSurface::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   if (registered_) {
     registry_->UnregisterOutputSurface(routing_id_, this);
   }
   client_->SetTreeActivationCallback(base::Closure());
   cc::OutputSurface::DetachFromClient();
@@ skipping 158 matching lines @@
 bool SynchronousCompositorOutputSurface::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
   return sender_->Send(message);
 }
 
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace content