Tracking text selection on the browser side in OOPIF.

content/public/test/text_input_test_utils.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 "content/public/test/text_input_test_utils.h"
 
 #include <unordered_set>
 
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
@@ skipping 40 matching lines @@
 
   void set_update_text_input_state_called_callback(
       const base::Closure& callback) {
     update_text_input_state_callback_ = callback;
   }
 
   void set_on_selection_bounds_changed_callback(const base::Closure& callback) {
     on_selection_bounds_changed_callback_ = callback;
   }
 
+  void set_on_text_selection_changed_callback(const base::Closure& callback) {
+    on_text_selection_changed_callback_ = callback;
+  }
+
   const RenderWidgetHostView* GetUpdatedView() const { return updated_view_; }
 
   bool text_input_state_changed() const { return text_input_state_changed_; }
 
   TextInputManager* text_input_manager() const { return text_input_manager_; }
 
   // TextInputManager::Observer implementations.
   void OnUpdateTextInputStateCalled(TextInputManager* text_input_manager,
                                     RenderWidgetHostViewBase* updated_view,
                                     bool did_change_state) override {
     if (text_input_manager_ != text_input_manager)
       return;
     text_input_state_changed_ = did_change_state;
     updated_view_ = updated_view;
     if (!update_text_input_state_callback_.is_null())
       update_text_input_state_callback_.Run();
   }
 
   void OnSelectionBoundsChanged(
       TextInputManager* text_input_manager_,
       RenderWidgetHostViewBase* updated_view) override {
     updated_view_ = updated_view;
     if (!on_selection_bounds_changed_callback_.is_null())
       on_selection_bounds_changed_callback_.Run();
   }
 
+  void OnTextSelectionChanged(TextInputManager* text_input_manager,
+                              RenderWidgetHostViewBase* updated_view) override {
+    updated_view_ = updated_view;
+    if (!on_text_selection_changed_callback_.is_null())
+      on_text_selection_changed_callback_.Run();
+  }
+
   // WebContentsObserver implementation.
   void WebContentsDestroyed() override { text_input_manager_ = nullptr; }
 
  private:
   TextInputManager* text_input_manager_;
   RenderWidgetHostViewBase* updated_view_;
   bool text_input_state_changed_;
   base::Closure update_text_input_state_callback_;
   base::Closure on_selection_bounds_changed_callback_;
+  base::Closure on_text_selection_changed_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(InternalObserver);
 };
 
 // This class observes the lifetime of a RenderWidgetHostView. An instance of
 // this class is used in TestRenderWidgetHostViewDestructionObserver to expose
 // the required observer API for testing outside of content/.
 class TestRenderWidgetHostViewDestructionObserver::InternalObserver
     : public RenderWidgetHostViewBaseObserver {
  public:
@@ skipping 131 matching lines @@
 void TextInputManagerTester::SetUpdateTextInputStateCalledCallback(
     const base::Closure& callback) {
   observer_->set_update_text_input_state_called_callback(callback);
 }
 
 void TextInputManagerTester::SetOnSelectionBoundsChangedCallback(
     const base::Closure& callback) {
   observer_->set_on_selection_bounds_changed_callback(callback);
 }
 
+void TextInputManagerTester::SetOnTextSelectionChangedCallback(
+    const base::Closure& callback) {
+  observer_->set_on_text_selection_changed_callback(callback);
+}
+
 bool TextInputManagerTester::GetTextInputType(ui::TextInputType* type) {
   DCHECK(observer_->text_input_manager());
   const TextInputState* state =
       observer_->text_input_manager()->GetTextInputState();
   if (!state)
     return false;
   *type = state->type;
   return true;
 }
 
 bool TextInputManagerTester::GetTextInputValue(std::string* value) {
   DCHECK(observer_->text_input_manager());
   const TextInputState* state =
       observer_->text_input_manager()->GetTextInputState();
   if (!state)
     return false;
   *value = state->value;
   return true;
 }
 
 const RenderWidgetHostView* TextInputManagerTester::GetActiveView() {
   DCHECK(observer_->text_input_manager());
   return observer_->text_input_manager()->active_view_for_testing();
 }
 
 const RenderWidgetHostView* TextInputManagerTester::GetUpdatedView() {
   return observer_->GetUpdatedView();
 }
 
+bool TextInputManagerTester::GetCurrentTextSelectionLength(size_t* length) {
+  DCHECK(observer_->text_input_manager());
+
+  if (!observer_->text_input_manager()->GetActiveWidget())
+    return false;
+
+  *length = observer_->text_input_manager()->GetTextSelection()->text.size();
+  return true;
+}
+
 bool TextInputManagerTester::IsTextInputStateChanged() {
   return observer_->text_input_state_changed();
 }
 
 TestRenderWidgetHostViewDestructionObserver::
     TestRenderWidgetHostViewDestructionObserver(RenderWidgetHostView* view)
     : observer_(
           new InternalObserver(static_cast<RenderWidgetHostViewBase*>(view))) {}
 
 TestRenderWidgetHostViewDestructionObserver::
@@ skipping 58 matching lines @@
   std::unique_ptr<TestInputMethodObserver> observer;
 
 #ifdef USE_AURA
   RenderWidgetHostViewAura* view = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   observer.reset(new InputMethodObserverAura(view->GetInputMethod()));
 #endif
   return observer;
 }
 
-}  // namespace content
+}  // namespace content