Move Range code to gfx.

content/browser/renderer_host/render_widget_host_view_mac.mm

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_mac.h"
 
 #import <objc/runtime.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/basictypes.h"
@@ skipping 913 matching lines @@
 #endif
     }
   }
 }
 
 void RenderWidgetHostViewMac::ImeCancelComposition() {
   [cocoa_view_ cancelComposition];
 }
 
 void RenderWidgetHostViewMac::ImeCompositionRangeChanged(
-    const ui::Range& range,
+    const gfx::Range& range,
     const std::vector<gfx::Rect>& character_bounds) {
   // The RangeChanged message is only sent with valid values. The current
   // caret position (start == end) will be sent if there is no IME range.
   [cocoa_view_ setMarkedRange:range.ToNSRange()];
   composition_range_ = range;
   composition_bounds_ = character_bounds;
 }
 
 void RenderWidgetHostViewMac::DidUpdateBackingStore(
     const gfx::Rect& scroll_rect,
@@ skipping 123 matching lines @@
   if ([NSApp respondsToSelector:@selector(stopSpeaking:)])
     [NSApp stopSpeaking:cocoa_view_];
 }
 
 //
 // RenderWidgetHostViewCocoa uses the stored selection text,
 // which implements NSServicesRequests protocol.
 //
 void RenderWidgetHostViewMac::SelectionChanged(const string16& text,
                                                size_t offset,
-                                               const ui::Range& range) {
+                                               const gfx::Range& range) {
   if (range.is_empty() || text.empty()) {
     selected_text_.clear();
   } else {
     size_t pos = range.GetMin() - offset;
     size_t n = range.length();
 
     DCHECK(pos + n <= text.length()) << "The text can not fully cover range.";
     if (pos >= text.length()) {
       DCHECK(false) << "The text can not cover range.";
       return;
@@ skipping 390 matching lines @@
   // Pass reasonable default values if unable to get the actual ones
   // (e.g. CVDisplayLink failed to return them because the display is
   // in sleep mode).
   static const int64 kOneOverSixtyMicroseconds = 16669;
   *timebase = base::TimeTicks::Now(),
   *interval = base::TimeDelta::FromMicroseconds(kOneOverSixtyMicroseconds);
 }
 
 bool RenderWidgetHostViewMac::GetLineBreakIndex(
     const std::vector<gfx::Rect>& bounds,
-    const ui::Range& range,
+    const gfx::Range& range,
     size_t* line_break_point) {
   DCHECK(line_break_point);
   if (range.start() >= bounds.size() || range.is_reversed() || range.is_empty())
     return false;
 
   // We can't check line breaking completely from only rectangle array. Thus we
   // assume the line breaking as the next character's y offset is larger than
   // a threshold. Currently the threshold is determined as minimum y offset plus
   // 75% of maximum height.
   // TODO(nona): Check the threshold is reliable or not.
   // TODO(nona): Bidi support.
   const size_t loop_end_idx = std::min(bounds.size(), range.end());
   int max_height = 0;
   int min_y_offset = kint32max;
   for (size_t idx = range.start(); idx < loop_end_idx; ++idx) {
     max_height = std::max(max_height, bounds[idx].height());
     min_y_offset = std::min(min_y_offset, bounds[idx].y());
   }
   int line_break_threshold = min_y_offset + (max_height * 3 / 4);
   for (size_t idx = range.start(); idx < loop_end_idx; ++idx) {
     if (bounds[idx].y() > line_break_threshold) {
       *line_break_point = idx;
       return true;
     }
   }
   return false;
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetFirstRectForCompositionRange(
-    const ui::Range& range,
-    ui::Range* actual_range) {
+    const gfx::Range& range,
+    gfx::Range* actual_range) {
   DCHECK(actual_range);
   DCHECK(!composition_bounds_.empty());
   DCHECK(range.start() <= composition_bounds_.size());
   DCHECK(range.end() <= composition_bounds_.size());
 
   if (range.is_empty()) {
     *actual_range = range;
     if (range.start() == composition_bounds_.size()) {
       return gfx::Rect(composition_bounds_[range.start() - 1].right(),
                        composition_bounds_[range.start() - 1].y(),
                        0,
                        composition_bounds_[range.start() - 1].height());
     } else {
       return gfx::Rect(composition_bounds_[range.start()].x(),
                        composition_bounds_[range.start()].y(),
                        0,
                        composition_bounds_[range.start()].height());
     }
   }
 
   size_t end_idx;
   if (!GetLineBreakIndex(composition_bounds_, range, &end_idx)) {
     end_idx = range.end();
   }
-  *actual_range = ui::Range(range.start(), end_idx);
+  *actual_range = gfx::Range(range.start(), end_idx);
   gfx::Rect rect = composition_bounds_[range.start()];
   for (size_t i = range.start() + 1; i < end_idx; ++i) {
     rect.Union(composition_bounds_[i]);
   }
   return rect;
 }
 
-ui::Range RenderWidgetHostViewMac::ConvertCharacterRangeToCompositionRange(
-    const ui::Range& request_range) {
+gfx::Range RenderWidgetHostViewMac::ConvertCharacterRangeToCompositionRange(
+    const gfx::Range& request_range) {
   if (composition_range_.is_empty())
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
 
   if (request_range.is_reversed())
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
 
   if (request_range.start() < composition_range_.start() ||
       request_range.start() > composition_range_.end() ||
       request_range.end() > composition_range_.end()) {
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
   }
 
-  return ui::Range(
+  return gfx::Range(
       request_range.start() - composition_range_.start(),
       request_range.end() - composition_range_.start());
 }
 
 bool RenderWidgetHostViewMac::GetCachedFirstRectForCharacterRange(
     NSRange range,
     NSRect* rect,
     NSRange* actual_range) {
   DCHECK(rect);
   // This exists to make IMEs more responsive, see http://crbug.com/115920
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewMac::GetFirstRectForCharacterRange");
 
   // If requested range is same as caret location, we can just return it.
-  if (selection_range_.is_empty() && ui::Range(range) == selection_range_) {
+  if (selection_range_.is_empty() && gfx::Range(range) == selection_range_) {
     if (actual_range)
       *actual_range = range;
     *rect = NSRectFromCGRect(caret_rect_.ToCGRect());
     return true;
   }
 
-  const ui::Range request_range_in_composition =
-      ConvertCharacterRangeToCompositionRange(ui::Range(range));
-  if (request_range_in_composition == ui::Range::InvalidRange())
+  const gfx::Range request_range_in_composition =
+      ConvertCharacterRangeToCompositionRange(gfx::Range(range));
+  if (request_range_in_composition == gfx::Range::InvalidRange())
     return false;
 
   // If firstRectForCharacterRange in WebFrame is failed in renderer,
   // ImeCompositionRangeChanged will be sent with empty vector.
   if (composition_bounds_.empty())
     return false;
   DCHECK_EQ(composition_bounds_.size(), composition_range_.length());
 
-  ui::Range ui_actual_range;
+  gfx::Range ui_actual_range;
   *rect = NSRectFromCGRect(GetFirstRectForCompositionRange(
                                request_range_in_composition,
                                &ui_actual_range).ToCGRect());
   if (actual_range) {
-    *actual_range = ui::Range(
+    *actual_range = gfx::Range(
         composition_range_.start() + ui_actual_range.start(),
         composition_range_.start() + ui_actual_range.end()).ToNSRange();
   }
   return true;
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
@@ skipping 707 matching lines @@
   // the keydown event, so that we can retain all necessary informations, such
   // as unmodifiedText, etc. And we need to set event.skip_in_browser to true to
   // prevent the browser from handling it again.
   // Note that, |textToBeInserted_| is a UTF-16 string, but it's fine to only
   // handle BMP characters here, as we can always insert non-BMP characters as
   // text.
   BOOL textInserted = NO;
   if (textToBeInserted_.length() >
       ((hasMarkedText_ || oldHasMarkedText) ? 0u : 1u)) {
     widgetHost->ImeConfirmComposition(
-        textToBeInserted_, ui::Range::InvalidRange(), false);
+        textToBeInserted_, gfx::Range::InvalidRange(), false);
     textInserted = YES;
   }
 
   // Updates or cancels the composition. If some text has been inserted, then
   // we don't need to cancel the composition explicitly.
   if (hasMarkedText_ && markedText_.length()) {
     // Sends the updated marked text to the renderer so it can update the
     // composition node in WebKit.
     // When marked text is available, |selectedRange_| will be the range being
     // selected inside the marked text.
     widgetHost->ImeSetComposition(markedText_, underlines_,
                                   selectedRange_.location,
                                   NSMaxRange(selectedRange_));
   } else if (oldHasMarkedText && !hasMarkedText_ && !textInserted) {
     if (unmarkTextCalled_) {
       widgetHost->ImeConfirmComposition(
-          string16(), ui::Range::InvalidRange(), false);
+          string16(), gfx::Range::InvalidRange(), false);
     } else {
       widgetHost->ImeCancelComposition();
     }
   }
 
   // If the key event was handled by the input method but it also generated some
   // edit commands, then we need to send the real key event and corresponding
   // edit commands here. This usually occurs when the input method wants to
   // finish current composition session but still wants the application to
   // handle the key event. See http://crbug.com/48161 for reference.
@@ skipping 1059 matching lines @@
   // text when it cancels an ongoing composition, i.e. I have never seen an
   // input method calls this method.
   hasMarkedText_ = NO;
   markedText_.clear();
   underlines_.clear();
 
   // If we are handling a key down event, then ConfirmComposition() will be
   // called in keyEvent: method.
   if (!handlingKeyDown_) {
     renderWidgetHostView_->render_widget_host_->ImeConfirmComposition(
-        string16(), ui::Range::InvalidRange(), false);
+        string16(), gfx::Range::InvalidRange(), false);
   } else {
     unmarkTextCalled_ = YES;
   }
 }
 
 - (void)setMarkedText:(id)string selectedRange:(NSRange)newSelRange
                               replacementRange:(NSRange)replacementRange {
   // An input method updates the composition string.
   // We send the given text and range to the renderer so it can update the
   // composition node of WebKit.
@@ skipping 72 matching lines @@
   // Text inserting might be initiated by other source instead of keyboard
   // events, such as the Characters dialog. In this case the text should be
   // sent as an input method event as well.
   // TODO(suzhe): It's hard for us to support replacementRange without accessing
   // the full web content.
   BOOL isAttributedString = [string isKindOfClass:[NSAttributedString class]];
   NSString* im_text = isAttributedString ? [string string] : string;
   if (handlingKeyDown_) {
     textToBeInserted_.append(base::SysNSStringToUTF16(im_text));
   } else {
-    ui::Range replacement_range(replacementRange);
+    gfx::Range replacement_range(replacementRange);
     renderWidgetHostView_->render_widget_host_->ImeConfirmComposition(
         base::SysNSStringToUTF16(im_text), replacement_range, false);
   }
 
   // Inserting text will delete all marked text automatically.
   hasMarkedText_ = NO;
 }
 
 - (void)insertText:(id)string {
   [self insertText:string replacementRange:NSMakeRange(NSNotFound, 0)];
@@ skipping 124 matching lines @@
   // Should not call [self unmarkText] here, because it'll send unnecessary
   // cancel composition IPC message to the renderer.
 }
 
 - (void)confirmComposition {
   if (!hasMarkedText_)
     return;
 
   if (renderWidgetHostView_->render_widget_host_)
     renderWidgetHostView_->render_widget_host_->ImeConfirmComposition(
-        string16(), ui::Range::InvalidRange(), false);
+        string16(), gfx::Range::InvalidRange(), false);
 
   [self cancelComposition];
 }
 
 - (void)setPluginImeActive:(BOOL)active {
   if (active == pluginImeActive_)
     return;
 
   pluginImeActive_ = active;
   if (!active) {
@@ skipping 167 matching lines @@
   return YES;
 }
 
 - (BOOL)isOpaque {
   if (renderWidgetHostView_->use_core_animation_)
     return YES;
   return [super isOpaque];
 }
 
 @end