Reland: cc: Fix size_t to int truncations in layers/ output/ playback/ quads/

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/location.h"
@@ skipping 319 matching lines @@
 }
 
 void Layer::ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer) {
   DCHECK(reference);
   DCHECK_EQ(reference->parent(), this);
   DCHECK(IsPropertyChangeAllowed());
 
   if (reference == new_layer.get())
     return;
 
-  int reference_index = IndexOfChild(reference);
-  if (reference_index == -1) {
+  // Find the index of reference, aborting if it doesn't exist.
+  auto reference_it =
+      std::find_if(children_.begin(), children_.end(),
+                   [reference](const scoped_refptr<Layer>& layer) {
+                     return layer.get() == reference;
+                   });
+  if (reference_it == children_.end()) {
     NOTREACHED();

[danakj, 2015/06/02 00:06:27]

Oh, yuck. Can you just DCHECK(reference_it != end) and not return?

[vmpstr, 2015/06/02 00:21:10]

Done.

     return;
   }
 
+  size_t reference_index = reference_it - children_.begin();
   reference->RemoveFromParent();
 
   if (new_layer.get()) {
     new_layer->RemoveFromParent();
     InsertChild(new_layer, reference_index);
   }
 }
 
-int Layer::IndexOfChild(const Layer* reference) {
-  for (size_t i = 0; i < children_.size(); ++i) {
-    if (children_[i].get() == reference)
-      return i;
-  }
-  return -1;
-}
-
 void Layer::SetBounds(const gfx::Size& size) {
   DCHECK(IsPropertyChangeAllowed());
   if (bounds() == size)
     return;
   bounds_ = size;
 
   if (!layer_tree_host_)
     return;
 
   if (ClipNode* clip_node = layer_tree_host_->property_trees()->clip_tree.Node(
@@ skipping 37 matching lines @@
   for (const Layer* layer = parent(); layer; layer = layer->parent()) {
     if (layer == ancestor)
       return true;
   }
   return false;
 }
 
 void Layer::RequestCopyOfOutput(
     scoped_ptr<CopyOutputRequest> request) {
   DCHECK(IsPropertyChangeAllowed());
-  int size = copy_requests_.size();
+  bool had_no_copy_requests = copy_requests_.empty();
   if (void* source = request->source()) {
     auto it = std::find_if(
         copy_requests_.begin(), copy_requests_.end(),
         [source](const CopyOutputRequest* x) { return x->source() == source; });
     if (it != copy_requests_.end())
       copy_requests_.erase(it);
   }
   if (request->IsEmpty())
     return;
   copy_requests_.push_back(request.Pass());
-  if (size == 0) {
+  if (had_no_copy_requests) {
     bool copy_request_added = true;
     UpdateNumCopyRequestsForSubtree(copy_request_added);
   }
   SetNeedsCommit();
 }
 
 void Layer::UpdateNumCopyRequestsForSubtree(bool add) {
   int change = add ? 1 : -1;
   for (Layer* layer = this; layer; layer = layer->parent()) {
     layer->num_layer_or_descendants_with_copy_request_ += change;
@@ skipping 826 matching lines @@
   // the pending tree will clobber any impl-side scrolling occuring on the
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
   if (layer_animation_controller_->scroll_offset_animation_was_interrupted())
     layer->PushScrollOffsetFromMainThreadAndClobberActiveValue(scroll_offset_);
   else
     layer->PushScrollOffsetFromMainThread(scroll_offset_);
   layer->SetScrollCompensationAdjustment(ScrollCompensationAdjustment());
 
   // Wrap the copy_requests_ in a PostTask to the main thread.
-  int size = copy_requests_.size();
+  bool had_copy_requests = !copy_requests_.empty();
   ScopedPtrVector<CopyOutputRequest> main_thread_copy_requests;
   for (ScopedPtrVector<CopyOutputRequest>::iterator it = copy_requests_.begin();
        it != copy_requests_.end();
        ++it) {
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
         layer_tree_host()->proxy()->MainThreadTaskRunner();
     scoped_ptr<CopyOutputRequest> original_request = copy_requests_.take(it);
     const CopyOutputRequest& original_request_ref = *original_request;
     scoped_ptr<CopyOutputRequest> main_thread_request =
         CopyOutputRequest::CreateRelayRequest(
             original_request_ref,
             base::Bind(&PostCopyCallbackToMainThread,
                        main_thread_task_runner,
                        base::Passed(&original_request)));
     main_thread_copy_requests.push_back(main_thread_request.Pass());
   }
   if (!copy_requests_.empty() && layer_tree_host_)
     layer_tree_host_->property_trees()->needs_rebuild = true;
-  if (size != 0)
+  if (had_copy_requests)
     UpdateNumCopyRequestsForSubtree(false);
   copy_requests_.clear();
   layer->PassCopyRequests(&main_thread_copy_requests);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
@@ skipping 340 matching lines @@
           ? layer_tree_host()->meta_information_sequence_number()
           : 0;
 }
 
 bool Layer::sorted_for_recursion() {
   return sorted_for_recursion_tracker_ ==
          layer_tree_host()->meta_information_sequence_number();
 }
 
 }  // namespace cc