Use emplace_back in RTree::Build

cc/base/rtree.h

 // Copyright (c) 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.
 
 #ifndef CC_BASE_RTREE_H_
 #define CC_BASE_RTREE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 34 matching lines @@
     DCHECK_EQ(0u, num_data_elements_);
 
     std::vector<Branch> branches;
     branches.reserve(items.size());
 
     for (size_t i = 0; i < items.size(); i++) {
       const gfx::Rect& bounds = bounds_getter(items[i]);
       if (bounds.IsEmpty())
         continue;
 
-      branches.push_back(Branch());
-      Branch& branch = branches.back();
-      branch.bounds = bounds;
-      branch.index = i;
+      branches.emplace_back(i, bounds);
     }
 
     num_data_elements_ = branches.size();
     if (num_data_elements_ == 1u) {
       nodes_.reserve(1);
       Node* node = AllocateNodeAtLevel(0);
       node->num_children = 1;
       node->children[0] = branches[0];
       root_.subtree = node;
       root_.bounds = branches[0].bounds;
@@ skipping 39 matching lines @@
   struct Branch {
     // When the node level is 0, then the node is a leaf and the branch has a
     // valid index pointing to an element in the vector that was used to build
     // this rtree. When the level is not 0, it's an internal node and it has a
     // valid subtree pointer.
     union {
       Node* subtree;
       size_t index;
     };
     gfx::Rect bounds;
+
+    Branch() {}
+    Branch(size_t index, const gfx::Rect& bounds)
+        : index(index), bounds(bounds) {}
   };
 
   struct Node {
     uint16_t num_children;
     uint16_t level;
     Branch children[kMaxChildren];
+
+    explicit Node(uint16_t level) : num_children(0), level(level) {}
   };
 
   void SearchRecursive(Node* root,
                        const gfx::Rect& query,
                        std::vector<size_t>* results) const;
 
   // Consumes the input array.
   Branch BuildRecursive(std::vector<Branch>* branches, int level);
   Node* AllocateNodeAtLevel(int level);
 
   // This is the count of data elements (rather than total nodes in the tree)
   size_t num_data_elements_;
   Branch root_;
   std::vector<Node> nodes_;
 
   DISALLOW_COPY_AND_ASSIGN(RTree);
 };
 
 }  // namespace cc
 
 #endif  // CC_BASE_RTREE_H_