RenderWidget/RenderView: encapsulate ViewHostMsg_Show, etc, in a callback

content/renderer/render_widget.h

 // Copyright (c) 2012 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_RENDERER_RENDER_WIDGET_H_
 #define CONTENT_RENDERER_RENDER_WIDGET_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 83 matching lines @@
 }
 
 namespace content {
 class CompositorDependencies;
 class ExternalPopupMenu;
 class FrameSwapMessageQueue;
 class ImeEventGuard;
 class PepperPluginInstanceImpl;
 class RenderFrameImpl;
 class RenderFrameProxy;
+class RenderViewImpl;
 class RenderWidgetCompositor;
 class RenderWidgetOwnerDelegate;
 class RenderWidgetScreenMetricsEmulator;
 class ResizingModeSelector;
 class TextInputClientObserver;
 struct ContextMenuParams;
 struct ResizeParams;
 
 // RenderWidget provides a communication bridge between a WebWidget and
 // a RenderWidgetHost, the latter of which lives in a different process.
 //
 // RenderWidget is used to implement:
 // - RenderViewImpl (deprecated)
 // - Fullscreen mode (RenderWidgetFullScreen)
 // - Popup "menus" (like the color chooser and date picker)
 // - Widgets for frames (for out-of-process iframe support)
 class CONTENT_EXPORT RenderWidget
     : public IPC::Listener,
       public IPC::Sender,
       NON_EXPORTED_BASE(virtual public blink::WebWidgetClient),
       public RenderWidgetCompositorDelegate,
       public RenderWidgetInputHandlerDelegate,
       public RenderWidgetScreenMetricsEmulatorDelegate,
       public base::RefCounted<RenderWidget> {
  public:
-  // Creates a new RenderWidget.  The opener_id is the routing ID of the
-  // RenderView that this widget lives inside.
-  static RenderWidget* Create(int32_t opener_id,
-                              CompositorDependencies* compositor_deps,
-                              blink::WebPopupType popup_type,
-                              const ScreenInfo& screen_info);
+  // Creates a new RenderWidget for a popup. |opener| is the RenderView that
+  // this widget lives inside.
+  static RenderWidget* CreateForPopup(RenderViewImpl* opener,
+                                      CompositorDependencies* compositor_deps,
+                                      blink::WebPopupType popup_type,
+                                      const ScreenInfo& screen_info);
 
   // Creates a new RenderWidget that will be attached to a RenderFrame.
   static RenderWidget* CreateForFrame(int widget_routing_id,
                                       bool hidden,
                                       const ScreenInfo& screen_info,
                                       CompositorDependencies* compositor_deps,
                                       blink::WebLocalFrame* frame);
 
   // Used by content_layouttest_support to hook into the creation of
   // RenderWidgets.
   using CreateRenderWidgetFunction = RenderWidget* (*)(int32_t,
                                                        CompositorDependencies*,
                                                        blink::WebPopupType,
                                                        const ScreenInfo&,
                                                        bool,
                                                        bool,
                                                        bool);
   using RenderWidgetInitializedCallback = void (*)(RenderWidget*);
+  using ShowCallback = base::Callback<void(RenderWidget* widget_to_show,
+                                           blink::WebNavigationPolicy policy,
+                                           const gfx::Rect& initial_rect)>;
   static void InstallCreateHook(
       CreateRenderWidgetFunction create_render_widget,
       RenderWidgetInitializedCallback render_widget_initialized_callback);
 
   // Closes a RenderWidget that was created by |CreateForFrame|.
   // TODO(avi): De-virtualize this once RenderViewImpl has-a RenderWidget.
   // https://crbug.com/545684
   virtual void CloseForFrame();
 
   int32_t routing_id() const { return routing_id_; }
@@ skipping 272 matching lines @@
   ~RenderWidget() override;
 
   static blink::WebFrameWidget* CreateWebFrameWidget(
       RenderWidget* render_widget,
       blink::WebLocalFrame* frame);
 
   // Creates a WebWidget based on the popup type.
   static blink::WebWidget* CreateWebWidget(RenderWidget* render_widget);
 
   // Called by Create() functions and subclasses to finish initialization.
-  void Init(int32_t opener_id, blink::WebWidget* web_widget);
+  // |show_callback| will be invoked once WebWidgetClient::show() occurs, and
+  // should be null if show() won't be triggered for this widget.
+  void Init(const ShowCallback& show_callback, blink::WebWidget* web_widget);
 
   // Allows the process to exit once the unload handler has finished, if there
   // are no other active RenderWidgets.
   void WasSwappedOut();
 
   void DoDeferredClose();
   void NotifyOnClose();
 
   gfx::Size GetSizeForWebWidget() const;
   virtual void ResizeWebWidget();
@@ skipping 158 matching lines @@
   // We are responsible for destroying this object via its Close method.
   // May be NULL when the window is closing.
   blink::WebWidget* webwidget_internal_;
 
   // The delegate of the owner of this object.
   RenderWidgetOwnerDelegate* owner_delegate_;
 
   // This is lazily constructed and must not outlive webwidget_.
   std::unique_ptr<RenderWidgetCompositor> compositor_;
 
-  // Set to the ID of the view that initiated creating this view, if any. When
-  // the view was initiated by the browser (the common case), this will be
-  // MSG_ROUTING_NONE. This is used in determining ownership when opening
-  // child tabs. See RenderWidget::createWebViewWithRequest.
-  //
-  // This ID may refer to an invalid view if that view is closed before this
-  // view is.
-  int32_t opener_id_;
-
   // The rect where this view should be initially shown.
   gfx::Rect initial_rect_;
 
   // We store the current cursor object so we can avoid spamming SetCursor
   // messages.
   WebCursor current_cursor_;
 
   // The size of the RenderWidget.
   gfx::Size size_;
 
@@ skipping 155 matching lines @@
 
  private:
   // Applies/Removes the DevTools device emulation transformation to/from a
   // window rect.
   void ScreenRectToEmulatedIfNeeded(blink::WebRect* window_rect) const;
   void EmulatedToScreenRectIfNeeded(blink::WebRect* window_rect) const;
 
   // Indicates whether this widget has focus.
   bool has_focus_;
 
+  // A callback into the creator/opener of this widget, to be executed when
+  // WebWidgetClient::show() occurs.
+  ShowCallback show_callback_;
+
 #if defined(OS_MACOSX)
   // Responds to IPCs from TextInputClientMac regarding getting string at given
   // position or range as well as finding character index at a given position.
   std::unique_ptr<TextInputClientObserver> text_input_client_observer_;
 #endif
 
   // This reference is set by the RenderFrame and is used to query the IME-
   // related state from the plugin to later send to the browser.
   PepperPluginInstanceImpl* focused_pepper_plugin_;
 
   // Stores edit commands associated to the next key event.
   // Will be cleared as soon as the next key event is processed.
   EditCommands edit_commands_;
 
   // This field stores drag/drop related info for the event that is currently
   // being handled. If the current event results in starting a drag/drop
   // session, this info is sent to the browser along with other drag/drop info.
   DragEventSourceInfo possible_drag_event_info_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidget);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_WIDGET_H_