Tracking SelectionBounds for all RenderWidgets on the Browser Side (Aura Only)

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"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/browser/renderer_host/render_widget_host_view_base_observer.h"
 #include "content/browser/renderer_host/text_input_manager.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/text_input_state.h"
+#include "content/common/view_messages.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/test/test_utils.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_observer.h"
 
 namespace ui {
 class TextInputClient;
 }
 
 namespace content {
 
+namespace {
+void DefaultTextInputManagerObserverCallback(TextInputManagerTester* tester) {}
+TextInputManagerTester::Callback default_text_input_manager_observer_callback =
+    base::Bind(&DefaultTextInputManagerObserverCallback);

[Charlie Reis, 2016/06/29 20:18:37]

We should not be adding new statically allocated objects.  There's
LAZY_INSTANCE_INITIALIZER if necessary, but can we avoid this?

[EhsanK, 2016/06/30 00:24:45]

I understand.

In initial patches of TextInputManager we had std::unique_ptr to callbacks which
would allow us to do:

if (callback_) callback_->Run()

and avoid the use of a static default fallback value. But we later changed that
along the review process. Would you suggest we use that idea?

[Charlie Reis, 2016/06/30 20:27:21]

I don't remember the objections to that approach, but it sounds reasonable if we
don't always have callbacks to run.  (It's also possible to keep a no-op
callback within InternalObserver rather than making it a global, so you can
decide which one looks nicer.)

[EhsanK, 2016/06/30 21:01:14]

In that sense, I think it might look more readable to keep unique_ptr and avoid
the no-op method altogether.

+}  // namespace
+
 // This class is an observer of TextInputManager associated with the provided
 // WebContents. An instance of this class is used in TextInputManagerTester to
 // expose the required API for testing outside of content/.
 class TextInputManagerTester::InternalObserver
     : public TextInputManager::Observer,
       public WebContentsObserver {
  public:
   InternalObserver(WebContents* web_contents, TextInputManagerTester* tester)
       : WebContentsObserver(web_contents),
         tester_(tester),
         updated_view_(nullptr),
-        text_input_state_changed_(false) {
+        text_input_state_changed_(false),
+        update_text_input_state_callback_(
+            default_text_input_manager_observer_callback),
+        on_selection_bounds_changed_callback_(
+            default_text_input_manager_observer_callback) {
     text_input_manager_ =
         static_cast<WebContentsImpl*>(web_contents)->GetTextInputManager();
     DCHECK(!!text_input_manager_);
     text_input_manager_->AddObserver(this);
   }
 
   ~InternalObserver() override {
     if (text_input_manager_)
       text_input_manager_->RemoveObserver(this);
   }
 
   void set_update_text_input_state_called_callback(
       const TextInputManagerTester::Callback& callback) {
     update_text_input_state_callback_ = callback;
   }
 
+  void set_on_selection_bounds_changed_callback(
+      const TextInputManagerTester::Callback& callback) {
+    on_selection_bounds_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;
     update_text_input_state_callback_.Run(tester_);
   }
 
+  void OnSelectionBoundsChanged(
+      TextInputManager* text_input_manager_,
+      RenderWidgetHostViewBase* updated_view) override {
+    updated_view_ = updated_view;
+    on_selection_bounds_changed_callback_.Run(tester_);
+  }
+
   // WebContentsObserver implementation.
   void WebContentsDestroyed() override { text_input_manager_ = nullptr; }
 
  private:
   TextInputManagerTester* tester_;
   TextInputManager* text_input_manager_;
   RenderWidgetHostViewBase* updated_view_;
   bool text_input_state_changed_;
   TextInputManagerTester::Callback update_text_input_state_callback_;
+  TextInputManagerTester::Callback on_selection_bounds_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 126 matching lines @@
 TextInputManagerTester::TextInputManagerTester(WebContents* web_contents)
     : observer_(new InternalObserver(web_contents, this)) {}
 
 TextInputManagerTester::~TextInputManagerTester() {}
 
 void TextInputManagerTester::SetUpdateTextInputStateCalledCallback(
     const Callback& callback) {
   observer_->set_update_text_input_state_called_callback(callback);
 }
 
+void TextInputManagerTester::SetOnSelectionBoundsChangedCallback(
+    const Callback& callback) {
+  observer_->set_on_selection_bounds_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;
 }
 
@@ skipping 88 matching lines @@
 
 #ifdef USE_AURA
   RenderWidgetHostViewAura* view = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   observer.reset(new InputMethodObserverAura(view->GetInputMethod()));
 #endif
   return observer;
 }
 
 }  // namespace content