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

content/browser/renderer_host/text_input_manager.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_TEXT_INPUT_MANAGER_H__
 #define CONTENT_BROWSER_RENDERER_HOST_TEXT_INPUT_MANAGER_H__
 
 #include <unordered_map>
+#include <utility>
 
 #include "base/observer_list.h"
 #include "content/common/content_export.h"
 #include "content/common/text_input_state.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/selection_bound.h"
+
+struct ViewHostMsg_SelectionBounds_Params;
 
 namespace content {
 
 class RenderWidgetHostImpl;
 class RenderWidgetHostView;
 class RenderWidgetHostViewBase;
 class WebContents;
 
 // A class which receives updates of TextInputState from multiple sources and
 // decides what the new TextInputState is. It also notifies the observers when
@@ skipping 11 matching lines @@
     // changed (e.g., Aura for updating IME).
     virtual void OnUpdateTextInputStateCalled(
         TextInputManager* text_input_manager,
         RenderWidgetHostViewBase* updated_view,
         bool did_update_state) {}
     // Called when |updated_view| has called ImeCancelComposition on
     // TextInputManager.
     virtual void OnImeCancelComposition(
         TextInputManager* text_input_manager,
         RenderWidgetHostViewBase* updated_view) {}
+    // Called when the selection bounds for the |updated_view| has changed.
+    virtual void OnSelectionBoundsChanged(
+        TextInputManager* text_input_manager,
+        RenderWidgetHostViewBase* updated_view) {}
   };
 
   TextInputManager();
   ~TextInputManager();
 
   // ---------------------------------------------------------------------------
   // The following methods can be used to obtain information about IME-related
   // state for the active RenderWidget.
 
   // Returns the currently active widget, i.e., the RWH which is associated with
   // |active_view_|.
   RenderWidgetHostImpl* GetActiveWidget() const;
 
   // Returns the TextInputState corresponding to |active_view_|.
   // Users of this method should not hold on to the pointer as it might become
   // dangling if the TextInputManager or |active_view_| might go away.
   const TextInputState* GetTextInputState();
 
+  // Returns the rect between selection bounds for the |active_view_|.
+  gfx::Rect GetSelectionBoundsRect();
+
   // ---------------------------------------------------------------------------
   // The following methods are called by RWHVs on the tab to update their IME-
   // related state.
 
   // Updates the TextInputState for |view|.
   void UpdateTextInputState(RenderWidgetHostViewBase* view,
                             const TextInputState& state);
 
   // The current IME composition has been cancelled on the renderer side for
   // the widget corresponding to |view|.
   void ImeCancelComposition(RenderWidgetHostViewBase* view);
 
+  void SelectionBoundsChanged(RenderWidgetHostViewBase* view,

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

Please add a comment about what selection bounds are.  It's a bit puzzling to me
that keyboard input triggers this, when it sounds like a gfx::Rect.

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

Good point.

This is not necessarily triggered by keyboard:
https://cs.chromium.org/chromium/src/content/renderer/render_widget.cc?sq=pac...

In aura, we use the selection bounds in determine the caret position for IME:
https://cs.chromium.org/chromium/src/content/browser/renderer_host/render_wid...
But there we use the type ui::SelectionBound which seems more relevant than
gfx::Rect. But why the bounds in IPC are of type gfx::Rect, I am not sure. Maybe
because InputMethod on ui/ side asks for a rect so initially they were
gfx::Rect? 

But apparently there has been movements in removing this IPC and use compositor
meta data. But IME (specifically for <webview>) has been a blocker for that. See
here:
https://cs.chromium.org/chromium/src/content/renderer/render_widget.cc?rcl=0&...

The rest of selection as I understand get updates through some compositing meta
data. That is as much as I could dig :P.

Finally, this update is only used by Mac and Aura.

+                              const ViewHostMsg_SelectionBounds_Params& params);
+
   // Registers the given |view| for tracking its TextInputState. This is called
   // by any view which has updates in its TextInputState (whether tab's RWHV or
   // that of a child frame). The |view| must unregister itself before being
   // destroyed (i.e., call TextInputManager::Unregister).
   void Register(RenderWidgetHostViewBase* view);
 
   // Clears the TextInputState from the |view|. If |view == active_view_|, this
   // call will lead to a TextInputState update since the TextInputState.type
   // should be reset to none.
   void Unregister(RenderWidgetHostViewBase* view);
 
   // Returns true if |view| is already registered.
   bool IsRegistered(RenderWidgetHostViewBase* view) const;
 
   // Add and remove observers for notifications regarding updates in the
   // TextInputState. Clients must be sure to remove themselves before they go
   // away.
   // Only the tab's RWHV should observer TextInputManager. In tests, however,
   // in addition to the tab's RWHV, one or more test observers might observe
   // TextInputManager.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   RenderWidgetHostViewBase* active_view_for_testing() { return active_view_; }
   size_t GetRegisteredViewsCountForTesting();
   ui::TextInputType GetTextInputTypeForViewForTesting(
       RenderWidgetHostViewBase* view);
 
  private:
+  template <class Value>
+  class ViewMap : public std::unordered_map<RenderWidgetHostViewBase*, Value> {
+  };
+
   void NotifyObserversAboutInputStateUpdate(RenderWidgetHostViewBase* view,
                                             bool did_update_state);
 
   // The view with active text input state, i.e., a focused <input> element.
   // It will be nullptr if no such view exists. Note that the active view
   // cannot have a |TextInputState.type| of ui::TEXT_INPUT_TYPE_NONE.
   RenderWidgetHostViewBase* active_view_;
 
-  std::unordered_map<RenderWidgetHostViewBase*, TextInputState>
-      text_input_state_map_;
+  ViewMap<TextInputState> text_input_state_map_;
+
+#if defined(USE_AURA)
+  // Maps a registered view to a pair of selection bounds where the first bound
+  // is selection anchor and the second is selection focus.
+  ViewMap<std::pair<gfx::SelectionBound, gfx::SelectionBound>>

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

I'm not a fan of using a map of pairs.  Can we have a struct rather than a pair
to make the members more explicit?

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

Acknowledged.

+      selection_bound_map_;
+#endif
 
   base::ObserverList<Observer> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(TextInputManager);
 };
 }
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_TEXT_INPUT_MANAGER_H__