Remove SVGTextMetrics Width/Height getters

third_party/WebKit/Source/core/layout/svg/SVGTextQuery.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010-2012. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 10 matching lines @@
 
 #include <algorithm>
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/api/LineLayoutSVGInlineText.h"
 #include "core/layout/line/InlineFlowBox.h"
 #include "core/layout/svg/LayoutSVGInlineText.h"
 #include "core/layout/svg/SVGTextFragment.h"
 #include "core/layout/svg/SVGTextMetrics.h"
 #include "core/layout/svg/line/SVGInlineTextBox.h"
-#include "platform/wtf/MathExtras.h"
 #include "platform/wtf/Vector.h"
 
 namespace blink {
 
 // Base structure for callback user data
 struct QueryData {
   QueryData()
       : is_vertical_text(false),
         current_offset(0),
         text_line_layout(nullptr),
@@ skipping 209 matching lines @@
 
 static float CalculateGlyphRange(const QueryData* query_data,
                                  const SVGTextFragment& fragment,
                                  unsigned start,
                                  unsigned end) {
   const MetricsList& metrics_list = query_data->text_line_layout.MetricsList();
   auto metrics = FindMetricsForCharacter(metrics_list, fragment, start);
   auto end_metrics = FindMetricsForCharacter(metrics_list, fragment, end);
   float glyph_range = 0;
   for (; metrics != end_metrics; ++metrics)
-    glyph_range +=
-        query_data->is_vertical_text ? metrics->Height() : metrics->Width();
+    glyph_range += metrics->Advance(query_data->is_vertical_text);
   return glyph_range;
 }
 
 // subStringLength() implementation
 struct SubStringLengthData : QueryData {
   SubStringLengthData(unsigned query_start_position, unsigned query_length)
       : start_position(query_start_position),
         length(query_length),
         sub_string_length(0) {}
 
@@ skipping 167 matching lines @@
 struct ExtentOfCharacterData : QueryData {
   ExtentOfCharacterData(unsigned query_position) : position(query_position) {}
 
   unsigned position;
   FloatRect extent;
 };
 
 static FloatRect PhysicalGlyphExtents(const QueryData* query_data,
                                       const SVGTextMetrics& metrics,
                                       const FloatPoint& glyph_position) {
-  // TODO(fs): Negative glyph extents seems kind of weird to have, but
-  // presently it can occur in some cases (like Arabic.)
-  FloatRect glyph_extents(glyph_position,
-                          FloatSize(std::max<float>(metrics.Width(), 0),
-                                    std::max<float>(metrics.Height(), 0)));
+  FloatRect glyph_extents(glyph_position, metrics.Extents());
 
   // If RTL, adjust the starting point to align with the LHS of the glyph
   // bounding box.
   if (!query_data->text_box->IsLeftToRightDirection()) {
     if (query_data->is_vertical_text)
       glyph_extents.Move(0, -glyph_extents.Height());
     else
       glyph_extents.Move(-glyph_extents.Width(), 0);
   }
   return glyph_extents;
@@ skipping 149 matching lines @@
     if (extent.Contains(data->position)) {
       // Compute the character offset of the glyph within the text node.
       unsigned offset_in_box = fragment.character_offset -
                                query_data->text_box->Start() + fragment_offset;
       data->offset_in_text_node = LogicalOffsetInTextNode(
           query_data->text_line_layout, query_data->text_box, offset_in_box);
       data->hit_layout_item = LineLayoutItem(data->text_line_layout);
       return true;
     }
     fragment_offset += metrics->length();
-    glyph_offset +=
-        data->is_vertical_text ? metrics->Height() : metrics->Width();
+    glyph_offset += metrics->Advance(data->is_vertical_text);
     ++metrics;
   }
   return false;
 }
 
 int SVGTextQuery::CharacterNumberAtPosition(const FloatPoint& position) const {
   CharacterNumberAtPositionData data(position);
   SpatialQuery(query_root_layout_object_, &data,
                CharacterNumberAtPositionCallback);
   return data.CharacterNumberWithin(query_root_layout_object_);
 }
 
 }  // namespace blink