Update TextSelection for non-user initiated events

chrome/browser/renderer_host/site_per_process_text_input_browsertest.cc

 // 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 <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/public/test/text_input_test_utils.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "ui/base/clipboard/clipboard.h"
 #include "ui/base/ime/composition_underline.h"
 #include "ui/base/ime/text_edit_commands.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/ime/text_input_mode.h"
 #include "ui/base/ime/text_input_type.h"
+#include "ui/base/test/ui_controls.h"
 #include "url/gurl.h"
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include "ui/base/ime/linux/text_edit_command_auralinux.h"
 #include "ui/base/ime/linux/text_edit_key_bindings_delegate_auralinux.h"
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // TextInputManager and IME Tests
 //
@@ skipping 225 matching lines @@
   const content::RenderWidgetHostView* const expected_view_;
   const size_t expected_length_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewTextSelectionObserver);
 };
 
 // This class observes all the text selection updates within a WebContents.
 class TextSelectionObserver : public TextInputManagerObserverBase {
  public:
   explicit TextSelectionObserver(content::WebContents* web_contents)
-      : TextInputManagerObserverBase(web_contents) {
+      : TextInputManagerObserverBase(web_contents), callback_called_(false) {
     tester()->SetOnTextSelectionChangedCallback(base::Bind(
         &TextSelectionObserver::VerifyChange, base::Unretained(this)));
   }
 
-  void WaitForSelectedText(const std::string& text) {
-    selected_text_ = text;
-    Wait();
+  void WaitForSelectedText(const std::string& text,
+                           bool user_initiated = true) {
+    expected_text_ = text;
+    expected_user_initiated_ = user_initiated;
+    if (callback_called_ && last_selected_text_ == expected_text_ &&
+        last_user_initiated_ == expected_user_initiated_) {
+      OnSuccess();
+    } else {
+      Wait();
+    }
   }
 
  private:
   void VerifyChange() {
-    if (base::UTF16ToUTF8(tester()->GetUpdatedView()->GetSelectedText()) ==
-        selected_text_) {
+    callback_called_ = true;
+
+    last_selected_text_ =
+        base::UTF16ToUTF8(tester()->GetUpdatedView()->GetSelectedText());
+    EXPECT_TRUE(tester()->GetTextSelectionUserInitiatedForView(
+        tester()->GetUpdatedView(), &last_user_initiated_));
+
+    if (last_selected_text_ == expected_text_ &&
+        last_user_initiated_ == expected_user_initiated_) {
       OnSuccess();
     }
   }
 
-  std::string selected_text_;
+  bool callback_called_;
+
+  std::string last_selected_text_;
+  std::string expected_text_;
+  bool last_user_initiated_;
+  bool expected_user_initiated_;
 
   DISALLOW_COPY_AND_ASSIGN(TextSelectionObserver);
 };
 
 // This class monitors all the changes in TextInputState and keeps a record of
 // the active views. There is no waiting and the recording process is
 // continuous.
 class RecordActiveViewsObserver {
  public:
   explicit RecordActiveViewsObserver(content::WebContents* web_contents)
@@ skipping 107 matching lines @@
   // Iteratively uses ChildFrameAt(frame, i) to get the i-th child frame
   // inside frame. For example, for 'a(b(c, d(e)))', [0] returns b, and
   // [0, 1, 0] returns e;
   content::RenderFrameHost* GetFrame(const IndexVector& indices) {
     content::RenderFrameHost* current = active_contents()->GetMainFrame();
     for (size_t index : indices)
       current = ChildFrameAt(current, index);
     return current;
   }
 
+  // Simulates a click on the middle of the first DOM element
+  // with the given |selector| in the given frame |rfh|. The |frame_index|
+  // parameter is used to find the child frame in the main frame and
+  // use its offset to calculate the click position.
+  void ClickFirstElementWithSelector(content::RenderFrameHost* rfh,
+                                     int frame_index,
+                                     const std::string& selector) {
+    int frame_x = 0;
+    int frame_y = 0;
+
+    if (rfh != active_contents()->GetMainFrame()) {
+      ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
+          active_contents()->GetMainFrame(),
+          "var frames = document.querySelectorAll('iframe');"
+          "var frame = frames[" +
+              std::to_string(frame_index) +
+              "];"
+              "domAutomationController.send(Math.floor(frame.offsetLeft));",
+          &frame_x));
+      ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
+          active_contents()->GetMainFrame(),
+          "var frames = document.querySelectorAll('iframe');"
+          "var frame = frames[" +
+              std::to_string(frame_index) +
+              "];"
+              "domAutomationController.send(Math.floor(frame.offsetTop));",
+          &frame_y));
+    }
+
+    int x;
+    ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
+        rfh,
+        "var bounds = document.querySelector('" + selector +
+            "').getBoundingClientRect();"
+            "domAutomationController.send("
+            "   Math.floor(bounds.left + bounds.width / 2));",
+        &x));
+    int y;
+    ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
+        rfh,
+        "var bounds = document.querySelector('" + selector +
+            "').getBoundingClientRect();"
+            "domAutomationController.send("
+            "   Math.floor(bounds.top + bounds.height / 2));",
+        &y));
+
+    auto content_bounds = active_contents()->GetContainerBounds();
+    ui_controls::SendMouseMove(x + frame_x + content_bounds.x(),
+                               y + frame_y + content_bounds.y());
+    ui_controls::SendMouseClick(ui_controls::LEFT);
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SitePerProcessTextInputManagerTest);
 };
 
 // The following test loads a page with multiple nested <iframe> elements which
 // are in or out of process with the main frame. Then an <input> field with
 // unique value is added to every single frame on the frame tree. The test then
 // creates a sequence of tab presses and verifies that after each key press, the
 // TextInputState.value reflects that of the focused input, i.e., the
 // TextInputManager is correctly tracking TextInputState across frames.
@@ skipping 540 matching lines @@
   };
 
   for (auto* frame : frames) {
     focus_frame_and_input(frame);
     EXPECT_TRUE(active_contents()->IsFocusedElementEditable());
     active_contents()->ClearFocusedElement();
     EXPECT_FALSE(active_contents()->IsFocusedElementEditable());
   }
 }
 
+// This test verifies that the TextInputManager notifies about a
+// text selection change event for both user and non-user (eg. JavaScript)
+// initiated cases. It is also tested whether TextSelection::user_initiated
+// is properly set. The content of the selection clipboard is also tested on
+// platforms where it is supported.
+// See: https://crbug.com/671986
+IN_PROC_BROWSER_TEST_F(SitePerProcessTextInputManagerTest,
+                       NonUserInitiatedTextSelection) {
+#if defined(USE_AURA) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  EXPECT_TRUE(!!clipboard);

[Lei Zhang, 2017/05/10 21:06:03]

ASSERT_TRUE() because if this fails, the test executable crashes, or if you
don't mind that, just omit it?

[Peter Varga, 2017/05/10 21:12:36]

I copied this from another clipboard test. I will change this.

+  clipboard->Clear(ui::CLIPBOARD_TYPE_SELECTION);
+#endif
+
+  CreateIframePage("a(b, c)");
+  std::vector<std::string> values{"node_a", "node_b", "node_c"};
+  std::vector<content::RenderFrameHost*> frames{GetFrame(IndexVector{}),
+                                                GetFrame(IndexVector{0}),
+                                                GetFrame(IndexVector{1})};
+
+  for (size_t i = 0; i < frames.size(); ++i)
+    AddInputFieldToFrame(frames[i], "text", values[i], true);
+
+  // Test text selection from JavaScript across frames (non-user initiated).
+  for (size_t i = 0; i < frames.size(); ++i) {
+    // Trigger text selection.
+    TextSelectionObserver trigger_observer(active_contents());
+    EXPECT_TRUE(
+        ExecuteScript(frames[i], "document.querySelector('input').select();"));
+    trigger_observer.WaitForSelectedText(values[i], false);
+
+#if defined(USE_AURA) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
+    // Non-user initiated text selection should not update the selection
+    // clipboard. See: https://crbug.com/12392
+    base::string16 result_text;
+    clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &result_text);
+    EXPECT_TRUE(result_text.empty());
+#endif
+
+    // Clear text selection.
+    TextSelectionObserver clear_observer(active_contents());
+    EXPECT_TRUE(ExecuteScript(frames[i], "document.getSelection().empty();"));
+    clear_observer.WaitForSelectedText("", false);
+  }
+
+  // Test text selection by user input across frames (user initiated).
+  for (size_t i = 0; i < frames.size(); ++i) {
+    // Click on element to have keyboard focus.
+    TextInputManagerChangeObserver input_observer(active_contents());
+    // Index of the main frame is 0. Thus align child frame index to it (i-1).
+    ASSERT_NO_FATAL_FAILURE(
+        ClickFirstElementWithSelector(frames[i], i - 1, "input"));
+    input_observer.Wait();
+
+    // Press ctrl+a to select text in the input field.
+    TextSelectionObserver trigger_observer(active_contents());
+    SimulateKeyPress(active_contents(), ui::DomKey::FromCharacter('A'),
+                     ui::DomCode::US_A, ui::VKEY_A, true, false, false, false);
+    trigger_observer.WaitForSelectedText(values[i], true);
+
+#if defined(USE_AURA) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
+    // User initiated text selection should update the selection clipboard.
+    base::string16 result_text;
+    clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &result_text);
+    EXPECT_EQ(base::ASCIIToUTF16(values[i]), result_text);
+#endif
+
+    // Click on element to clear text selection.
+    TextSelectionObserver clear_observer(active_contents());
+    // Index of the main frame is 0. Thus align child frame index to it (i-1).
+    ASSERT_NO_FATAL_FAILURE(
+        ClickFirstElementWithSelector(frames[i], i - 1, "input"));
+    clear_observer.WaitForSelectedText("", true);
+  }
+}
+
 // TODO(ekaramad): The following tests are specifically written for Aura and are
 // based on InputMethodObserver. Write similar tests for Mac/Android/Mus
 // (crbug.com/602723).
 #if defined(USE_AURA)
 // -----------------------------------------------------------------------------
 // Input Method Observer Tests
 //
 // The following tests will make use of the InputMethodObserver to verify that
 // OOPIF pages interact properly with the InputMethod through the tab's view.
 
@@ skipping 374 matching lines @@
 
   // Closing this WebContents while we still hold on to our TestBrowserClient.
   EXPECT_TRUE(browser()->tab_strip_model()->CloseWebContentsAt(
       1, TabStripModel::CLOSE_USER_GESTURE));
 
   // For the cleanup of the original WebContents in tab index 0.
   content::SetBrowserClientForTesting(old_browser_client);
 }
 #endif  //  defined(MAC_OSX)
 #endif  // !defined(OS_ANDROID)