AndroidOverlay implementation using Dialog.

content/browser/frame_host/render_frame_host_impl.h

 // Copyright 2013 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_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/optional.h"
 #include "base/strings/string16.h"
 #include "base/supports_user_data.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/loader/global_routing_id.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/webui/web_ui_impl.h"
 #include "content/common/accessibility_mode.h"
@@ skipping 96 matching lines @@
                                                 const base::string16& html)>;
 
   // An accessibility reset is only allowed to prevent very rare corner cases
   // or race conditions where the browser and renderer get out of sync. If
   // this happens more than this many times, kill the renderer.
   static const int kMaxAccessibilityResets = 5;
 
   static RenderFrameHostImpl* FromID(int process_id, int routing_id);
   static RenderFrameHostImpl* FromAXTreeID(
       ui::AXTreeIDRegistry::AXTreeID ax_tree_id);
+#if defined(OS_ANDROID)
+  static RenderFrameHostImpl* FromOverlayRoutingToken(
+      const base::UnguessableToken& token);
+#endif
 
   ~RenderFrameHostImpl() override;
 
   // RenderFrameHost
   int GetRoutingID() override;
   ui::AXTreeIDRegistry::AXTreeID GetAXTreeID() override;
   SiteInstanceImpl* GetSiteInstance() override;
   RenderProcessHost* GetProcess() override;
   RenderWidgetHostView* GetView() override;
   RenderFrameHostImpl* GetParent() override;
@@ skipping 478 matching lines @@
   bool has_focused_editable_element() const {
     return has_focused_editable_element_;
   }
 
   // Cancels any blocked request for the frame and its subframes.
   void CancelBlockedRequestsForFrame();
 
 #if defined(OS_ANDROID)
   base::android::ScopedJavaLocalRef<jobject> GetJavaRenderFrameHost();
   service_manager::InterfaceProvider* GetJavaInterfaces() override;
+
+  // Returns an unguessable token for this RFHI.  This provides a temporary way
+  // to identify a RenderFrameHost that's compatible with IPC.  Else, one needs
+  // to send pid + RoutingID, but one cannot send pid.  One can get it from the
+  // channel, but this makes it much harder to get wrong.
+  // Once media switches to mojo, we should be able to remove this in favor of
+  // sending a mojo overlay factory.
+  const base::UnguessableToken& GetOverlayRoutingToken();
 #endif
 
  protected:
   friend class RenderFrameHostFactory;
 
   // |flags| is a combination of CreateRenderFrameFlags.
   // TODO(nasko): Remove dependency on RenderViewHost here. RenderProcessHost
   // should be the abstraction needed here, but we need RenderViewHost to pass
   // into WebContentsObserver::FrameDetached for now.
   RenderFrameHostImpl(SiteInstance* site_instance,
@@ skipping 138 matching lines @@
   void OnSetHasReceivedUserGesture();
 
 #if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
   void OnShowPopup(const FrameHostMsg_ShowPopup_Params& params);
   void OnHidePopup();
 #endif
 #if defined(OS_ANDROID)
   void OnNavigationHandledByEmbedder();
   void ForwardGetInterfaceToRenderFrame(const std::string& interface_name,
                                         mojo::ScopedMessagePipeHandle pipe);
+
+  // Called when the frame would like an overlay routing token.  This will
+  // create one if needed.  Either way, it will send it to the frame.
+  void OnRequestOverlayRoutingToken();
 #endif
   void OnShowCreatedWindow(int pending_widget_routing_id,
                            WindowOpenDisposition disposition,
                            const gfx::Rect& initial_rect,
                            bool user_gesture);
 
   // Registers Mojo interfaces that this frame host makes available.
   void RegisterMojoInterfaces();
 
   // Resets any waiting state of this RenderFrameHost that is no longer
@@ skipping 366 matching lines @@
 #if defined(OS_ANDROID)
   // An InterfaceProvider for Java-implemented interfaces that are scoped to
   // this RenderFrameHost. This provides access to interfaces implemented in
   // Java in the browser process to C++ code in the browser process.
   std::unique_ptr<service_manager::InterfaceProvider> java_interfaces_;
 
   // An InterfaceRegistry that forwards interface requests from Java to the
   // RenderFrame. This provides access to interfaces implemented in the renderer
   // to Java code in the browser process.
   std::unique_ptr<service_manager::InterfaceRegistry> java_interface_registry_;
+
+  // IPC-friendly token that represents this host for AndroidOverlays, if we
+  // have created one yet.
+  base::Optional<base::UnguessableToken> overlay_routing_token_;
 #endif
 
   // NOTE: This must be the last member.
   base::WeakPtrFactory<RenderFrameHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_