Fixing flakiness of TextureLayerChangeInvisibleMailboxTest

cc/trees/proxy_main.cc

 // Copyright 2015 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 "cc/trees/proxy_main.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/memory/ptr_util.h"
@@ skipping 18 matching lines @@
                      TaskRunnerProvider* task_runner_provider)
     : layer_tree_host_(layer_tree_host),
       task_runner_provider_(task_runner_provider),
       layer_tree_host_id_(layer_tree_host->GetId()),
       max_requested_pipeline_stage_(NO_PIPELINE_STAGE),
       current_pipeline_stage_(NO_PIPELINE_STAGE),
       final_pipeline_stage_(NO_PIPELINE_STAGE),
       commit_waits_for_activation_(false),
       started_(false),
       defer_commits_(false),
+      frame_sink_bound_weak_factory_(this),
       weak_factory_(this) {
   TRACE_EVENT0("cc", "ProxyMain::ProxyMain");
   DCHECK(task_runner_provider_);
   DCHECK(IsMainThread());
 }
 
 ProxyMain::~ProxyMain() {
   TRACE_EVENT0("cc", "ProxyMain::~ProxyMain");
   DCHECK(IsMainThread());
   DCHECK(!started_);
@@ skipping 32 matching lines @@
 
 void ProxyMain::SetAnimationEvents(std::unique_ptr<MutatorEvents> events) {
   TRACE_EVENT0("cc", "ProxyMain::SetAnimationEvents");
   DCHECK(IsMainThread());
   layer_tree_host_->SetAnimationEvents(std::move(events));
 }
 
 void ProxyMain::DidLoseCompositorFrameSink() {
   TRACE_EVENT0("cc", "ProxyMain::DidLoseCompositorFrameSink");
   DCHECK(IsMainThread());
+  frame_sink_bound_weak_factory_.InvalidateWeakPtrs();

[danakj, 2017/04/18 20:58:42]

I would either add a unit test for this case too or remove this change.

[Saman Sami, 2017/04/18 21:37:13]

Removed to keep things simple. If we ever need this behaviour, we can revisit.

   layer_tree_host_->DidLoseCompositorFrameSink();
 }
 
 void ProxyMain::RequestNewCompositorFrameSink() {
   TRACE_EVENT0("cc", "ProxyMain::RequestNewCompositorFrameSink");
   DCHECK(IsMainThread());
   layer_tree_host_->RequestNewCompositorFrameSink();
 }
 
 void ProxyMain::DidInitializeCompositorFrameSink(bool success) {
@@ skipping 190 matching lines @@
 
 bool ProxyMain::CommitToActiveTree() const {
   // With ProxyMain, we use a pending tree and activate it once it's ready to
   // draw to allow input to modify the active tree and draw during raster.
   return false;
 }
 
 void ProxyMain::SetCompositorFrameSink(
     CompositorFrameSink* compositor_frame_sink) {
   ImplThreadTaskRunner()->PostTask(
-      FROM_HERE, base::BindOnce(&ProxyImpl::InitializeCompositorFrameSinkOnImpl,
-                                base::Unretained(proxy_impl_.get()),
-                                compositor_frame_sink));
+      FROM_HERE,
+      base::BindOnce(&ProxyImpl::InitializeCompositorFrameSinkOnImpl,
+                     base::Unretained(proxy_impl_.get()), compositor_frame_sink,
+                     frame_sink_bound_weak_factory_.GetWeakPtr()));
 }
 
 void ProxyMain::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "ProxyMain::SetVisible", "visible", visible);
   ImplThreadTaskRunner()->PostTask(
       FROM_HERE, base::BindOnce(&ProxyImpl::SetVisibleOnImpl,
                                 base::Unretained(proxy_impl_.get()), visible));
 }
 
 void ProxyMain::SetNeedsAnimate() {
@@ skipping 158 matching lines @@
         base::BindOnce(&ProxyImpl::MainFrameWillHappenOnImplForTesting,
                        base::Unretained(proxy_impl_.get()), &completion,
                        &main_frame_will_happen));
     completion.Wait();
   }
   return main_frame_will_happen;
 }
 
 void ProxyMain::ReleaseCompositorFrameSink() {
   DCHECK(IsMainThread());
+  frame_sink_bound_weak_factory_.InvalidateWeakPtrs();
   DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
   CompletionEvent completion;
   ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::BindOnce(&ProxyImpl::ReleaseCompositorFrameSinkOnImpl,
                      base::Unretained(proxy_impl_.get()), &completion));
   completion.Wait();
 }
 
 void ProxyMain::UpdateBrowserControlsState(BrowserControlsState constraints,
@@ skipping 27 matching lines @@
 
 bool ProxyMain::IsImplThread() const {
   return task_runner_provider_->IsImplThread();
 }
 
 base::SingleThreadTaskRunner* ProxyMain::ImplThreadTaskRunner() {
   return task_runner_provider_->ImplThreadTaskRunner();
 }
 
 }  // namespace cc