Migrate WTF::HashMap::get() to ::at()

third_party/WebKit/Source/platform/graphics/paint/GeometryMapperTest.cpp

 // Copyright 2016 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 "platform/graphics/paint/GeometryMapper.h"
 
 #include "platform/geometry/GeometryTestHelpers.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/BoxReflection.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
@@ skipping 124 matching lines @@
                        inputRect, localPropertyTreeState.transform(),          \
                        ancestorPropertyTreeState.transform()));                \
     EXPECT_RECT_EQ(expectedTransformedRect,                                    \
                    geometryMapper->sourceToDestinationRect(                    \
                        inputRect, localPropertyTreeState.transform(),          \
                        ancestorPropertyTreeState.transform()));                \
     if (ancestorPropertyTreeState.transform() !=                               \
         localPropertyTreeState.transform()) {                                  \
       EXPECT_EQ(expectedTransformToAncestor,                                   \
                 getTransformCache(ancestorPropertyTreeState)                   \
-                    .get(localPropertyTreeState.transform()));                 \
+                    .at(localPropertyTreeState.transform()));                  \
     }                                                                          \
     if (ancestorPropertyTreeState.clip() != localPropertyTreeState.clip()) {   \
       EXPECT_EQ(expectedClipInAncestorSpace,                                   \
                 getClipCache(ancestorPropertyTreeState)                        \
-                    .get(localPropertyTreeState.clip()))                       \
+                    .at(localPropertyTreeState.clip()))                        \
           << expectedClipInAncestorSpace.rect().toString() << " "              \
           << getClipCache(ancestorPropertyTreeState)                           \
-                 .get(localPropertyTreeState.clip())                           \
+                 .at(localPropertyTreeState.clip())                            \
                  .rect()                                                       \
                  .toString();                                                  \
     }                                                                          \
   } while (false)
 
 TEST_F(GeometryMapperTest, Root) {
   FloatRect input(0, 0, 100, 100);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, input, input,
@@ skipping 95 matching lines @@
   FloatRect input(0, 0, 100, 100);
   TransformationMatrix final = rotateTransform * scaleTransform;
   FloatRect output = final.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, final, FloatClipRect(), localState,
                  rootPropertyTreeState(), hasRadius);
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(rotateTransform,
-            getTransformCache(rootPropertyTreeState()).get(transform1.get()));
+            getTransformCache(rootPropertyTreeState()).at(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsScaleAndTranslation) {
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          scaleTransform, FloatPoint3D());
 
   TransformationMatrix translateTransform;
   translateTransform.translate(100, 0);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, translateTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   FloatRect input(0, 0, 100, 100);
   // Note: unlike NestedTransforms, the order of these transforms matters. This
   // tests correct order of matrix multiplication.
   TransformationMatrix final = scaleTransform * translateTransform;
   FloatRect output = final.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, final, FloatClipRect(), localState,
                  rootPropertyTreeState(), hasRadius);
 
   // Check the cached matrix for the intermediate transform.
-  EXPECT_EQ(scaleTransform, getTransformCache(rootPropertyTreeState())
+  EXPECT_EQ(scaleTransform,
+            getTransformCache(rootPropertyTreeState())
 
-                                .get(transform1.get()));
+                .at(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   TransformationMatrix scaleTransform;
@@ skipping 518 matching lines @@
   FloatRect input(100, 100, 50, 50);
   // Reflection is at (50, 100, 50, 50).
   FloatRect output(50, 100, 100, 50);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, input, TransformationMatrix(), FloatClipRect(),
                  localState, rootPropertyTreeState(), hasRadius);
 }
 
 }  // namespace blink