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 "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"
@@ skipping 230 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) {

[nasko, 2017/05/04 16:10:24]

Has this CL been run through "git cl format"?

[Peter Varga, 2017/05/04 16:33:45]

Yes it has been. Actually the script put this two initialization into the same
line :)

     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|.
+  void ClickFirstElementWithSelector(const std::string& selector) {
+    int x;
+    ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
+        active_contents(),
+        "var bounds = document.querySelector('" + selector +
+            "').getBoundingClientRect();"
+            "domAutomationController.send("
+            "    Math.floor(bounds.left + bounds.width / 2));",
+        &x));
+    int y;
+    ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
+        active_contents(),
+        "var bounds = document.querySelector('" + selector +
+            "').getBoundingClientRect();"
+            "domAutomationController.send("
+            "    Math.floor(bounds.top + bounds.height / 2));",
+        &y));
+    content::SimulateMouseClickAt(active_contents(), 0,
+                                  blink::WebMouseEvent::Button::kLeft,
+                                  gfx::Point(x, y));
+  }
+
  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);
+  clipboard->Clear(ui::CLIPBOARD_TYPE_SELECTION);
+#endif
+
+  CreateIframePage("a()");

[EhsanK, 2017/05/04 00:16:31]

I think the test belongs to somewhere else but I leave that to creis@ to decide
(the scenario you are testing does not include any OOPIFs). 

[Peter Varga, 2017/05/04 07:30:39]

I agree with that this file is probably not the best place for this test.
However, I couldn't find any better. This seems to be the only one which holds
"complex" tests based on TextInputManager.

I really need help or advice where to place this test.

[nasko, 2017/05/04 16:10:24]

Why not extend the test to cover actual OOPIFs? That way not only we verify the
change itself, but we verify it works across OOPIFs too.

[Peter Varga, 2017/05/04 16:33:45]

Because I'm not sure how to test OOPIF. Any hint/suggestion/doc how to test or
what to test?

[EhsanK, 2017/05/08 16:56:25]

Some suggestions:
You could start by reusing some other examples. For starters, set the string to
something like "a(b())" which corresponds to a page in domain A and a frame in
domain B, i.e,:
 -A----------
|            |
| --B------- |
||          ||
||          ||
| ---------- |
 ------------
 There will be two RFHs for this example. On is the main frame and the other for
the <iframe>. In this file, I use GetFrame() to get a specific frame, e.g.
GetFrame(IndexVector{}) returns the main frame and GetFrame(IndexVector{0})
returns the first child of it which is the <iframe> in domain B. Feel free to
reuse something in other SPP tests such as
site_per_process_interactive_browsertest.cc and
chrome_site_per_process_browsertest.cc.

After you get your frames then the test (I believe) can be repeated for both.
Just remember to focus the right frame by passing input or "window.focus()" or
w/e way you find fit.

[Peter Varga, 2017/05/09 06:42:29]

Thank you for the suggestions. I did something similar in patch set 2.

[EhsanK, 2017/05/09 15:16:16]

Acknowledged.

+
+  content::RenderFrameHost* frame = GetFrame(IndexVector{});
+  AddInputFieldToFrame(frame, "text", "Chromium", true);
+
+  // Trigger text selection from JavaScript
+  {
+    TextSelectionObserver observer(active_contents());
+    EXPECT_TRUE(
+        ExecuteScript(frame, "document.querySelector('input').select();"));
+    observer.WaitForSelectedText("Chromium", 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 selecton from JavaScript
+  {
+    TextSelectionObserver observer(active_contents());
+    EXPECT_TRUE(ExecuteScript(frame, "document.getSelection().empty();"));
+    observer.WaitForSelectedText("", false);
+  }
+
+  // Trigger text selection by user input
+  {
+    TextSelectionObserver observer(active_contents());
+    // Click on element to have keyboard focus
+    ASSERT_NO_FATAL_FAILURE(ClickFirstElementWithSelector("input"));
+    // Press ctrl+a to select text in the input field
+    SimulateKeyPress(active_contents(), ui::DomKey::FromCharacter('A'),
+                     ui::DomCode::US_A, ui::VKEY_A, true, false, false, false);
+    observer.WaitForSelectedText("Chromium", true);
+  }
+
+#if defined(USE_AURA) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  // User initiated text selection should update the selection clipboard
+  clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &result_text);
+  EXPECT_EQ(base::ASCIIToUTF16("Chromium"), result_text);
+#endif
+
+  // Clear text selection by user input
+  {
+    TextSelectionObserver observer(active_contents());
+    // Click on element to clear text selection
+    ASSERT_NO_FATAL_FAILURE(ClickFirstElementWithSelector("input"));
+    observer.WaitForSelectedText("", true);
+  }
+
+#if defined(USE_AURA) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  // Empty selection should not clear the selection clipboard
+  clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &result_text);
+  EXPECT_EQ(base::ASCIIToUTF16("Chromium"), result_text);
+#endif
+}
+
 // 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)