Switch cc to std::unordered_*.

cc/trees/layer_tree_host_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_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
+#include <unordered_map>
+#include <utility>
 
 #include "base/auto_reset.h"
-#include "base/containers/hash_tables.h"
 #include "base/containers/small_map.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
@@ skipping 1151 matching lines @@
 }
 
 void LayerTreeHostImpl::RemoveRenderPasses(FrameData* frame) {
   // There is always at least a root RenderPass.
   DCHECK_GE(frame->render_passes.size(), 1u);
 
   // A set of RenderPasses that we have seen.
   std::set<RenderPassId> pass_exists;
   // A set of RenderPassDrawQuads that we have seen (stored by the RenderPasses
   // they refer to).
-  base::SmallMap<base::hash_map<RenderPassId, int>> pass_references;
+  base::SmallMap<std::unordered_map<RenderPassId, int, RenderPassIdHash>>
+      pass_references;
 
   // Iterate RenderPasses in draw order, removing empty render passes (except
   // the root RenderPass).
   for (size_t i = 0; i < frame->render_passes.size(); ++i) {
     RenderPass* pass = frame->render_passes[i].get();
 
     // Remove orphan RenderPassDrawQuads.
     for (auto it = pass->quad_list.begin(); it != pass->quad_list.end();) {
       if (it->material != DrawQuad::RENDER_PASS) {
         ++it;
@@ skipping 2082 matching lines @@
   }
   return str;
 }
 
 void LayerTreeHostImpl::RegisterScrollbarAnimationController(
     int scroll_layer_id) {
   if (settings().scrollbar_animator == LayerTreeSettings::NO_ANIMATOR)
     return;
   if (ScrollbarAnimationControllerForId(scroll_layer_id))
     return;
-  scrollbar_animation_controllers_.add(
+  // TODO(davidben): Is this the same as using operator[]? The check above

[danakj, 2016/01/14 21:12:32]

You're worried for the case where the scroll_layer_id exists in the map, but the
scoped_ptr value is null? I think that won't happen. The only place the
controller is changed is here and unregister. So it either sets a pointer or
erases the key.

[davidben, 2016/01/14 21:28:19]

I'm worried about the case where scroll_layer_id exists in the map.
ScopedPtrHashMap::add acts like unordered_map::insert in that it apparently does
nothing if the key already exists, whereas assigning to operator[] will always
modify the map.

I would be pretty surprised if this code actively wants this behavior, but I
wasn't sure so left it like this to ask you about. Will switch to operator[] if
that's the desired behavior, although it is a little odd that the check on line
3291 isn't quiiiite the right check.

[danakj, 2016/01/14 21:31:54]

Yah it is a bit awkward. I think operator[] will be fine tho, we shouldn't have
null values in the map since the only place that sets them is here and
CreateScrollbarAnimationController won't return null (without hitting a DCHECK).

[davidben, 2016/01/21 01:33:58]

Done.

+  // doesn't quite work if scroll_layer_id gets modified in
+  // ScrollbarAnimationControllerForId.
+  scrollbar_animation_controllers_.insert(std::make_pair(
       scroll_layer_id,
-      active_tree_->CreateScrollbarAnimationController(scroll_layer_id));
+      active_tree_->CreateScrollbarAnimationController(scroll_layer_id)));
 }
 
 void LayerTreeHostImpl::UnregisterScrollbarAnimationController(
     int scroll_layer_id) {
   scrollbar_animation_controllers_.erase(scroll_layer_id);
 }
 
 ScrollbarAnimationController*
 LayerTreeHostImpl::ScrollbarAnimationControllerForId(
     int scroll_layer_id) const {
   if (InnerViewportScrollLayer() && OuterViewportScrollLayer() &&
       scroll_layer_id == InnerViewportScrollLayer()->id())
     scroll_layer_id = OuterViewportScrollLayer()->id();
   auto i = scrollbar_animation_controllers_.find(scroll_layer_id);
   if (i == scrollbar_animation_controllers_.end())
     return nullptr;
-  return i->second;
+  return i->second.get();
 }
 
 void LayerTreeHostImpl::PostDelayedScrollbarAnimationTask(
     const base::Closure& task,
     base::TimeDelta delay) {
   client_->PostDelayedAnimationTaskOnImplThread(task, delay);
 }
 
 // TODO(danakj): Make this a return value from the Animate() call instead of an
 // interface on LTHI. (Also, crbug.com/551138.)
@@ skipping 472 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc