Fix template angle bracket syntax in inspector

Source/core/inspector/InspectorLayerTreeAgent.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 62 matching lines @@
         .setX(rect.x)
         .setY(rect.y)
         .setHeight(rect.height)
         .setWidth(rect.width);
     RefPtr<TypeBuilder::LayerTree::ScrollRect> scrollRectObject = TypeBuilder::LayerTree::ScrollRect::create()
         .setRect(rectObject.release())
         .setType(type);
     return scrollRectObject.release();
 }
 
-static PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > buildScrollRectsForLayer(GraphicsLayer* graphicsLayer)
+static PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>> buildScrollRectsForLayer(GraphicsLayer* graphicsLayer)
 {
-    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > scrollRects = TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>::create();
+    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>> scrollRects = TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>::create();
     blink::WebLayer* webLayer = graphicsLayer->platformLayer();
     for (size_t i = 0; i < webLayer->nonFastScrollableRegion().size(); ++i) {
         scrollRects->addItem(buildScrollRect(webLayer->nonFastScrollableRegion()[i], TypeBuilder::LayerTree::ScrollRect::Type::RepaintsOnScroll));
     }
     for (size_t i = 0; i < webLayer->touchEventHandlerRegion().size(); ++i) {
         scrollRects->addItem(buildScrollRect(webLayer->touchEventHandlerRegion()[i], TypeBuilder::LayerTree::ScrollRect::Type::TouchEventHandler));
     }
     if (webLayer->haveWheelEventHandlers()) {
         blink::WebRect webRect(webLayer->position().x, webLayer->position().y, webLayer->bounds().width, webLayer->bounds().height);
         scrollRects->addItem(buildScrollRect(webRect, TypeBuilder::LayerTree::ScrollRect::Type::WheelEventHandler));
@@ skipping 19 matching lines @@
     if (!parent)
         parent = graphicsLayer->replicatedLayer();
     if (parent)
         layerObject->setParentLayerId(idForLayer(parent));
     if (!graphicsLayer->contentsAreVisible())
         layerObject->setInvisible(true);
     const TransformationMatrix& transform = graphicsLayer->transform();
     if (!transform.isIdentity()) {
         TransformationMatrix::FloatMatrix4 flattenedMatrix;
         transform.toColumnMajorFloatArray(flattenedMatrix);
-        RefPtr<TypeBuilder::Array<double> > transformArray = TypeBuilder::Array<double>::create();
+        RefPtr<TypeBuilder::Array<double>> transformArray = TypeBuilder::Array<double>::create();
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(flattenedMatrix); ++i)
             transformArray->addItem(flattenedMatrix[i]);
         layerObject->setTransform(transformArray);
         const FloatPoint3D& transformOrigin = graphicsLayer->transformOrigin();
         // FIXME: rename these to setTransformOrigin*
         if (webLayer->bounds().width > 0)
             layerObject->setAnchorX(transformOrigin.x() / webLayer->bounds().width);
         else
             layerObject->setAnchorX(0.0);
         if (webLayer->bounds().height > 0)
             layerObject->setAnchorY(transformOrigin.y() / webLayer->bounds().height);
         else
             layerObject->setAnchorY(0.0);
         layerObject->setAnchorZ(transformOrigin.z());
     }
-    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > scrollRects = buildScrollRectsForLayer(graphicsLayer);
+    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>> scrollRects = buildScrollRectsForLayer(graphicsLayer);
     if (scrollRects)
         layerObject->setScrollRects(scrollRects.release());
     return layerObject;
 }
 
 InspectorLayerTreeAgent::InspectorLayerTreeAgent(Page* page)
     : InspectorBaseAgent<InspectorLayerTreeAgent>("LayerTree")
     , m_frontend(0)
     , m_page(page)
 {
@@ skipping 56 matching lines @@
         return;
 
     RefPtr<TypeBuilder::DOM::Rect> domRect = TypeBuilder::DOM::Rect::create()
         .setX(rect.x())
         .setY(rect.y())
         .setWidth(rect.width())
         .setHeight(rect.height());
     m_frontend->layerPainted(idForLayer(graphicsLayer), domRect.release());
 }
 
-PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> > InspectorLayerTreeAgent::buildLayerTree()
+PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer>> InspectorLayerTreeAgent::buildLayerTree()
 {
     RenderLayerCompositor* compositor = renderLayerCompositor();
     if (!compositor || !compositor->inCompositingMode())
         return nullptr;
 
     LayerIdToNodeIdMap layerIdToNodeIdMap;
-    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> > layers = TypeBuilder::Array<TypeBuilder::LayerTree::Layer>::create();
+    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer>> layers = TypeBuilder::Array<TypeBuilder::LayerTree::Layer>::create();
     buildLayerIdToNodeIdMap(compositor->rootRenderLayer(), layerIdToNodeIdMap);
     gatherGraphicsLayers(rootGraphicsLayer(), layerIdToNodeIdMap, layers);
     return layers.release();
 }
 
 void InspectorLayerTreeAgent::buildLayerIdToNodeIdMap(RenderLayer* root, LayerIdToNodeIdMap& layerIdToNodeIdMap)
 {
     if (root->hasCompositedLayerMapping()) {
         if (Node* node = root->renderer()->generatingNode()) {
             GraphicsLayer* graphicsLayer = root->compositedLayerMapping()->childForSuperlayers();
             layerIdToNodeIdMap.set(graphicsLayer->platformLayer()->id(), idForNode(node));
         }
     }
     for (RenderLayer* child = root->firstChild(); child; child = child->nextSibling())
         buildLayerIdToNodeIdMap(child, layerIdToNodeIdMap);
     if (!root->renderer()->isRenderIFrame())
         return;
     FrameView* childFrameView = toFrameView(toRenderPart(root->renderer())->widget());
     if (RenderView* childRenderView = childFrameView->renderView()) {
         if (RenderLayerCompositor* childCompositor = childRenderView->compositor())
             buildLayerIdToNodeIdMap(childCompositor->rootRenderLayer(), layerIdToNodeIdMap);
     }
 }
 
-void InspectorLayerTreeAgent::gatherGraphicsLayers(GraphicsLayer* root, HashMap<int, int>& layerIdToNodeIdMap, RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> >& layers)
+void InspectorLayerTreeAgent::gatherGraphicsLayers(GraphicsLayer* root, HashMap<int, int>& layerIdToNodeIdMap, RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer>>& layers)
 {
     int layerId = root->platformLayer()->id();
     if (m_pageOverlayLayerIds.find(layerId) != WTF::kNotFound)
         return;
     layers->addItem(buildObjectForLayer(root, layerIdToNodeIdMap.get(layerId)));
     if (GraphicsLayer* replica = root->replicaLayer())
         gatherGraphicsLayers(replica, layerIdToNodeIdMap, layers);
     for (size_t i = 0, size = root->children().size(); i < size; ++i)
         gatherGraphicsLayers(root->children()[i], layerIdToNodeIdMap, layers);
 }
@@ skipping 46 matching lines @@
         *errorString = "Not in compositing mode";
         return nullptr;
     }
 
     GraphicsLayer* result = findLayerById(rootGraphicsLayer(), id);
     if (!result)
         *errorString = "No layer matching given id found";
     return result;
 }
 
-void InspectorLayerTreeAgent::compositingReasons(ErrorString* errorString, const String& layerId, RefPtr<TypeBuilder::Array<String> >& reasonStrings)
+void InspectorLayerTreeAgent::compositingReasons(ErrorString* errorString, const String& layerId, RefPtr<TypeBuilder::Array<String>>& reasonStrings)
 {
     const GraphicsLayer* graphicsLayer = layerById(errorString, layerId);
     if (!graphicsLayer)
         return;
     CompositingReasons reasonsBitmask = graphicsLayer->compositingReasons();
     reasonStrings = TypeBuilder::Array<String>::create();
     for (size_t i = 0; i < kNumberOfCompositingReasons; ++i) {
         if (!(reasonsBitmask & kCompositingReasonStringMap[i].reason))
             continue;
         reasonStrings->addItem(kCompositingReasonStringMap[i].shortName);
@@ skipping 35 matching lines @@
     bool newEntry = m_snapshotById.add(*snapshotId, snapshot).isNewEntry;
     ASSERT_UNUSED(newEntry, newEntry);
 }
 
 void InspectorLayerTreeAgent::loadSnapshot(ErrorString* errorString, const RefPtr<JSONArray>& tiles, String* snapshotId)
 {
     if (!tiles->length()) {
         *errorString = "Invalid argument, no tiles provided";
         return;
     }
-    Vector<RefPtr<PictureSnapshot::TilePictureStream> > decodedTiles;
+    Vector<RefPtr<PictureSnapshot::TilePictureStream>> decodedTiles;
     decodedTiles.grow(tiles->length());
     for (size_t i = 0; i < tiles->length(); ++i) {
         RefPtr<JSONObject> item;
         if (!tiles->get(i)->asObject(&item)) {
             *errorString = "Invalid argument, array item is not an object";
             return;
         }
         double x = 0, y = 0;
         String picture;
         if (!item->getNumber("x", &x) || !item->getNumber("y", &y)
@@ skipping 36 matching lines @@
         return nullptr;
     }
     return it->value.get();
 }
 
 void InspectorLayerTreeAgent::replaySnapshot(ErrorString* errorString, const String& snapshotId, const int* fromStep, const int* toStep, const double* scale, String* dataURL)
 {
     const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
     if (!snapshot)
         return;
-    OwnPtr<Vector<char> > base64Data = snapshot->replay(fromStep ? *fromStep : 0, toStep ? *toStep : 0, scale ? *scale : 1.0);
+    OwnPtr<Vector<char>> base64Data = snapshot->replay(fromStep ? *fromStep : 0, toStep ? *toStep : 0, scale ? *scale : 1.0);
     if (!base64Data) {
         *errorString = "Image encoding failed";
         return;
     }
     StringBuilder url;
     url.appendLiteral("data:image/png;base64,");
     url.reserveCapacity(url.length() + base64Data->size());
     url.append(base64Data->begin(), base64Data->size());
     *dataURL = url.toString();
 }
 
 static bool parseRect(const JSONObject& object, FloatRect* rect)
 {
     double x = 0, y = 0;
     double width = 0, height = 0;
     if (!object.getNumber("x", &x) || !object.getNumber("y", &y) || !object.getNumber("width", &width) || !object.getNumber("width", &height))
         return false;
     *rect = FloatRect(x, y, width, height);
     return true;
 }
 
-void InspectorLayerTreeAgent::profileSnapshot(ErrorString* errorString, const String& snapshotId, const int* minRepeatCount, const double* minDuration, const RefPtr<JSONObject>* clipRect, RefPtr<TypeBuilder::Array<TypeBuilder::Array<double> > >& outTimings)
+void InspectorLayerTreeAgent::profileSnapshot(ErrorString* errorString, const String& snapshotId, const int* minRepeatCount, const double* minDuration, const RefPtr<JSONObject>* clipRect, RefPtr<TypeBuilder::Array<TypeBuilder::Array<double>>>& outTimings)
 {
     const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
     if (!snapshot)
         return;
     FloatRect rect;
     if (clipRect && !parseRect(**clipRect, &rect)) {
         *errorString = "Invalid argument, missing required field";
         return;
     }
     OwnPtr<PictureSnapshot::Timings> timings = snapshot->profile(minRepeatCount ? *minRepeatCount : 1, minDuration ? *minDuration : 0, clipRect ? &rect : 0);
-    outTimings = TypeBuilder::Array<TypeBuilder::Array<double> >::create();
+    outTimings = TypeBuilder::Array<TypeBuilder::Array<double>>::create();
     for (size_t i = 0; i < timings->size(); ++i) {
         const Vector<double>& row = (*timings)[i];
-        RefPtr<TypeBuilder::Array<double> > outRow = TypeBuilder::Array<double>::create();
+        RefPtr<TypeBuilder::Array<double>> outRow = TypeBuilder::Array<double>::create();
         for (size_t j = 0; j < row.size(); ++j)
             outRow->addItem(row[j]);
         outTimings->addItem(outRow.release());
     }
 }
 
-void InspectorLayerTreeAgent::snapshotCommandLog(ErrorString* errorString, const String& snapshotId, RefPtr<TypeBuilder::Array<JSONObject> >& commandLog)
+void InspectorLayerTreeAgent::snapshotCommandLog(ErrorString* errorString, const String& snapshotId, RefPtr<TypeBuilder::Array<JSONObject>>& commandLog)
 {
     const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
     if (!snapshot)
         return;
     commandLog = TypeBuilder::Array<JSONObject>::runtimeCast(snapshot->snapshotCommandLog());
 }
 
 void InspectorLayerTreeAgent::willAddPageOverlay(const GraphicsLayer* layer)
 {
     m_pageOverlayLayerIds.append(layer->platformLayer()->id());
 }
 
 void InspectorLayerTreeAgent::didRemovePageOverlay(const GraphicsLayer* layer)
 {
     size_t index = m_pageOverlayLayerIds.find(layer->platformLayer()->id());
     if (index == WTF::kNotFound)
         return;
     m_pageOverlayLayerIds.remove(index);
 }
 
 
 } // namespace blink