Make RenderViewImpl::OnForceRedraw more robust

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/layer_tree_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1465 matching lines @@
 }
 
 void LayerTreeImpl::QueuePinnedSwapPromise(
     std::unique_ptr<SwapPromise> swap_promise) {
   DCHECK(IsActiveTree());
   DCHECK(swap_promise);
   pinned_swap_promise_list_.push_back(std::move(swap_promise));
 }
 
 void LayerTreeImpl::PassSwapPromises(
-    std::vector<std::unique_ptr<SwapPromise>>* new_swap_promise) {
-  for (const auto& swap_promise : swap_promise_list_)
-    swap_promise->DidNotSwap(SwapPromise::SWAP_FAILS);
+    std::vector<std::unique_ptr<SwapPromise>>* new_swap_promises) {
+  for (auto& swap_promise : swap_promise_list_) {
+    if (swap_promise->DidNotSwap(SwapPromise::SWAP_FAILS)) {
+      // |swap_promise| must remain active, so place it to |new_swap_promises|
+      // in order to keep it alive.
+      new_swap_promises->push_back(std::move(swap_promise));
+    }
+  }
   swap_promise_list_.clear();
-  swap_promise_list_.swap(*new_swap_promise);
+  swap_promise_list_.swap(*new_swap_promises);
 }
 
 void LayerTreeImpl::FinishSwapPromises(CompositorFrameMetadata* metadata) {
   for (const auto& swap_promise : swap_promise_list_)
     swap_promise->DidSwap(metadata);
   swap_promise_list_.clear();
   for (const auto& swap_promise : pinned_swap_promise_list_)
     swap_promise->DidSwap(metadata);
   pinned_swap_promise_list_.clear();
 }
 
 void LayerTreeImpl::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
-  for (const auto& swap_promise : swap_promise_list_)
-    swap_promise->DidNotSwap(reason);
-  swap_promise_list_.clear();
+  {
+    std::vector<std::unique_ptr<SwapPromise>> persistent_swap_promises;
+    for (auto& swap_promise : swap_promise_list_) {
+      if (swap_promise->DidNotSwap(SwapPromise::SWAP_FAILS)) {

[piman, 2016/08/03 16:38:55]

this should be |reason| instead of |SWAP_FAILS|

[svartmetal, 2016/08/04 14:58:49]

Fixed.

+        persistent_swap_promises.push_back(std::move(swap_promise));
+      }
+    }
+    // |persistent_swap_promises| will remain active even when swap fails.
+    swap_promise_list_.swap(persistent_swap_promises);
+  }
   for (const auto& swap_promise : pinned_swap_promise_list_)
     swap_promise->DidNotSwap(reason);

[piman, 2016/08/03 16:38:55]

Should the logic apply here too?

[svartmetal, 2016/08/04 14:58:48]

I think, it should (to be consistent). But maybe we should reconsider the
concept of pinned swap promises as we have generalized way to create persistent
swap promises...  

   pinned_swap_promise_list_.clear();
 }
 
 void LayerTreeImpl::DidModifyTilePriorities() {
   layer_tree_host_impl_->DidModifyTilePriorities();
 }
 
 void LayerTreeImpl::set_ui_resource_request_queue(
     const UIResourceRequestQueue& queue) {
   ui_resource_request_queue_ = queue;
@@ skipping 515 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks and replicas.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc