Mac: Implement firstRectForCharacterRange:actualRange in BridgedContentView.

ui/views/cocoa/bridged_native_widget_unittest.mm

 // Copyright 2014 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.
 
 #import "ui/views/cocoa/bridged_native_widget.h"
 
 #import <Cocoa/Cocoa.h>
 
 #import "base/mac/foundation_util.h"
 #import "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #import "testing/gtest_mac.h"
 #import "ui/base/cocoa/window_size_constants.h"
 #include "ui/base/ime/input_method.h"
 #import "ui/gfx/test/ui_cocoa_test_helper.h"
+#import "ui/gfx/mac/coordinate_conversion.h"
 #import "ui/views/cocoa/bridged_content_view.h"
 #import "ui/views/cocoa/native_widget_mac_nswindow.h"
 #import "ui/views/cocoa/views_nswindow_delegate.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/native_widget_mac.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_observer.h"
 
 using base::ASCIIToUTF16;
 using base::SysNSStringToUTF8;
 using base::SysNSStringToUTF16;
 using base::SysUTF8ToNSString;
 
 #define EXPECT_EQ_RANGE(a, b)        \
   EXPECT_EQ(a.location, b.location); \
   EXPECT_EQ(a.length, b.length);
 
 namespace {
 
 // Empty range shortcut for readibility.
 NSRange EmptyRange() {
   return NSMakeRange(NSNotFound, 0);
 }
 
+// Sets |composition_text| as the composition text with caret placed at
+// |caret_pos| and updates |caret_range|.
+void SetCompositionText(ui::TextInputClient* client,
+                        const base::string16& composition_text,
+                        const int caret_pos,
+                        NSRange* caret_range) {
+  ui::CompositionText composition;
+  composition.selection = gfx::Range(caret_pos);
+  composition.text = composition_text;
+  client->SetCompositionText(composition);
+  if (caret_range)
+    *caret_range = NSMakeRange(caret_pos, 0);
+}
+
+// Returns a zero width rectangle corresponding to current caret position.
+gfx::Rect GetCaretBounds(const ui::TextInputClient* client) {
+  gfx::Rect caret_bounds = client->GetCaretBounds();
+  caret_bounds.set_width(0);
+  return caret_bounds;
+}
+
+// Returns a zero width rectangle corresponding to caret bounds when it's placed
+// at |caret_pos| and updates |caret_range|.
+gfx::Rect GetCaretBoundsForPosition(ui::TextInputClient* client,
+                                    const base::string16& composition_text,
+                                    const int caret_pos,
+                                    NSRange* caret_range) {
+  SetCompositionText(client, composition_text, caret_pos, caret_range);
+  return GetCaretBounds(client);
+}
+
+// Returns the expected boundary rectangle for characters of |composition_text|
+// within the |query_range|.
+gfx::Rect GetExpectedBoundsForRange(ui::TextInputClient* client,
+                                    const base::string16& composition_text,
+                                    NSRange query_range) {
+  gfx::Rect left_caret = GetCaretBoundsForPosition(client, composition_text,
+                                                   query_range.location, nil);
+  gfx::Rect right_caret = GetCaretBoundsForPosition(
+      client, composition_text, query_range.location + query_range.length, nil);
+
+  // The expected bounds correspond to the area between the left and right caret
+  // positions.
+  return gfx::Rect(left_caret.x(), left_caret.y(),
+                   right_caret.x() - left_caret.x(), left_caret.height());
+}
+
 }  // namespace
 
 // Class to override -[NSWindow toggleFullScreen:] to a no-op. This simulates
 // NSWindow's behavior when attempting to toggle fullscreen state again, when
 // the last attempt failed but Cocoa has not yet sent
 // windowDidFailToEnterFullScreen:.
 @interface BridgedNativeWidgetTestFullScreenWindow : NativeWidgetMacNSWindow {
  @private
   int ignoredToggleFullScreenCount_;
 }
@@ skipping 65 matching lines @@
     // before the tests covering the Init() flow are ready to do that.
     init_params_.type = Widget::InitParams::TYPE_WINDOW_FRAMELESS;
 
     // To control the lifetime without an actual window that must be closed,
     // tests in this file need to use WIDGET_OWNS_NATIVE_WIDGET.
     init_params_.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 
     // Opacity defaults to "infer" which is usually updated by ViewsDelegate.
     init_params_.opacity = Widget::InitParams::OPAQUE_WINDOW;
 
+    init_params_.bounds = gfx::Rect(100, 100, 100, 100);
+
     native_widget_mac_->GetWidget()->Init(init_params_);
   }
 
  protected:
   scoped_ptr<Widget> widget_;
   MockNativeWidgetMac* native_widget_mac_;  // Weak. Owned by |widget_|.
 
   // Make the InitParams available to tests to cover initialization codepaths.
   Widget::InitParams init_params_;
 };
@@ skipping 26 matching lines @@
 
 BridgedNativeWidgetTest::BridgedNativeWidgetTest() {
 }
 
 BridgedNativeWidgetTest::~BridgedNativeWidgetTest() {
 }
 
 void BridgedNativeWidgetTest::InstallTextField(const std::string& text) {
   Textfield* textfield = new Textfield();
   textfield->SetText(ASCIIToUTF16(text));
+  textfield->SetBoundsRect(init_params_.bounds);
   view_->AddChildView(textfield);
 
   // Request focus so the InputMethod can dispatch events to the RootView, and
   // have them delivered to the textfield. Note that focusing a textfield
   // schedules a task to flash the cursor, so this requires |message_loop_|.
   textfield->RequestFocus();
 
   [ns_view_ setTextInputClient:textfield];
 }
 
@@ skipping 311 matching lines @@
   EXPECT_EQ("a", GetText());
   EXPECT_EQ_RANGE(NSMakeRange(1, 0), [ns_view_ selectedRange]);
 
   // Should succeed after moving left first.
   [ns_view_ doCommandBySelector:@selector(moveLeft:)];
   [ns_view_ doCommandBySelector:@selector(deleteForward:)];
   EXPECT_EQ("", GetText());
   EXPECT_EQ_RANGE(NSMakeRange(0, 0), [ns_view_ selectedRange]);
 }
 
+// Test firstRectForCharacterRange:actualRange for cases where query range is
+// empty or outside composition range.
+TEST_F(BridgedNativeWidgetTest, TextInput_FirstRectForCharacterRange_Caret) {
+  InstallTextField("");
+  ui::TextInputClient* client = [ns_view_ textInputClient];
+
+  // No composition. Ensure bounds and range corresponding to the current caret
+  // position are returned.
+  // Initially selection range will be [0, 0].
+  NSRange caret_range = NSMakeRange(0, 0);
+  NSRange query_range = NSMakeRange(1, 1);
+  NSRange actual_range;
+  NSRect rect = [ns_view_ firstRectForCharacterRange:query_range
+                                         actualRange:&actual_range];
+  EXPECT_EQ(GetCaretBounds(client), gfx::ScreenRectFromNSRect(rect));
+  EXPECT_EQ_RANGE(caret_range, actual_range);
+
+  // Set composition with caret before second character ('e').
+  const base::string16 kTestString = base::ASCIIToUTF16("test_str");
+  const size_t kTextLength = 8;
+  SetCompositionText(client, kTestString, 1, &caret_range);
+
+  // Test bounds returned for empty range before second character ('e') are same
+  // as caret bounds when placed before second character.
+  query_range = NSMakeRange(1, 0);
+  rect = [ns_view_ firstRectForCharacterRange:query_range
+                                  actualRange:&actual_range];
+  EXPECT_EQ(GetCaretBoundsForPosition(client, kTestString, 1, &caret_range),
+            gfx::ScreenRectFromNSRect(rect));
+  EXPECT_EQ_RANGE(query_range, actual_range);
+
+  // Test bounds returned for empty range after the composition text are same as
+  // caret bounds when placed after the composition text.
+  query_range = NSMakeRange(kTextLength, 0);
+  rect = [ns_view_ firstRectForCharacterRange:query_range
+                                  actualRange:&actual_range];
+  EXPECT_NE(GetCaretBoundsForPosition(client, kTestString, 1, &caret_range),
+            gfx::ScreenRectFromNSRect(rect));
+  EXPECT_EQ(
+      GetCaretBoundsForPosition(client, kTestString, kTextLength, &caret_range),
+      gfx::ScreenRectFromNSRect(rect));
+  EXPECT_EQ_RANGE(query_range, actual_range);
+
+  // Query outside composition range. Ensure bounds and range corresponding to
+  // the current caret position are returned.
+  query_range = NSMakeRange(kTextLength + 1, 0);
+  rect = [ns_view_ firstRectForCharacterRange:query_range
+                                  actualRange:&actual_range];
+  EXPECT_EQ(GetCaretBounds(client), gfx::ScreenRectFromNSRect(rect));
+  EXPECT_EQ_RANGE(caret_range, actual_range);
+
+  // Make sure not crashing by passing null pointer instead of actualRange.
+  rect = [ns_view_ firstRectForCharacterRange:query_range actualRange:nullptr];
+}
+
+// Test firstRectForCharacterRange:actualRange for non-empty query ranges within
+// the composition range.
+TEST_F(BridgedNativeWidgetTest, TextInput_FirstRectForCharacterRange) {
+  InstallTextField("");
+  ui::TextInputClient* client = [ns_view_ textInputClient];
+
+  // Set composition text.

[tapted, 2016/01/04 02:28:10]

nit: this comment doesn't add much

[karandeepb, 2016/01/04 04:33:56]

Done.

+  const base::string16 kTestString = base::ASCIIToUTF16("test_str");
+  const size_t kTextLength = 8;
+  SetCompositionText(client, kTestString, 1, nil);

[tapted, 2016/01/04 02:28:10]

so here, `nullptr` is slightly more correct than `nil`. (I think that the degree
to which reviewers really care is diminishing though, so there's a good chance
nothing would be said about it).

I guess it's useful to consider something like

NSString* y = nil;
NSRange* x = nil;
printf("%lu", y.length);  // prints 0
printf("%lu", x->length);  // crashes

So, using "nil" could make readers think about it differently, e.g. think some
operations are safe when they're not.

[karandeepb, 2016/01/04 04:33:56]

Done.

+
+  // Query bounds for the whole composition string.
+  NSRange query_range = NSMakeRange(0, kTextLength);
+  NSRange actual_range;
+  NSRect rect = [ns_view_ firstRectForCharacterRange:query_range
+                                         actualRange:&actual_range];
+  EXPECT_EQ(GetExpectedBoundsForRange(client, kTestString, query_range),
+            gfx::ScreenRectFromNSRect(rect));
+  EXPECT_EQ_RANGE(query_range, actual_range);
+
+  // Query bounds for the substring "est_".
+  query_range = NSMakeRange(1, 4);
+  rect = [ns_view_ firstRectForCharacterRange:query_range
+                                  actualRange:&actual_range];
+  EXPECT_EQ(GetExpectedBoundsForRange(client, kTestString, query_range),
+            gfx::ScreenRectFromNSRect(rect));
+  EXPECT_EQ_RANGE(query_range, actual_range);
+}
+
 typedef BridgedNativeWidgetTestBase BridgedNativeWidgetSimulateFullscreenTest;
 
 // Simulate the notifications that AppKit would send out if a fullscreen
 // operation begins, and then fails and must abort. This notification sequence
 // was determined by posting delayed tasks to toggle fullscreen state and then
 // mashing Ctrl+Left/Right to keep OSX in a transition between Spaces to cause
 // the fullscreen transition to fail.
 TEST_F(BridgedNativeWidgetSimulateFullscreenTest, FailToEnterAndExit) {
   if (base::mac::IsOSSnowLeopard())
     return;
@@ skipping 58 matching lines @@
   [center postNotificationName:NSWindowDidExitFullScreenNotification
                         object:window];
   EXPECT_EQ(1, [window ignoredToggleFullScreenCount]);  // No change.
   EXPECT_FALSE(bridge()->target_fullscreen_state());
 
   widget_->CloseNow();
 }
 
 }  // namespace test
 }  // namespace views