src/content/renderer/render_frame_impl.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_RENDERER_RENDER_FRAME_IMPL_H_
   6 #define CONTENT_RENDERER_RENDER_FRAME_IMPL_H_
   7
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/files/file_path.h"
  12 #include "base/gtest_prod_util.h"
  13 #include "base/id_map.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/observer_list.h"
  16 #include "base/process/process_handle.h"
  17 #include "content/public/common/javascript_message_type.h"
  18 #include "content/public/common/referrer.h"
  19 #include "content/public/renderer/render_frame.h"
  20 #include "content/renderer/media/webmediaplayer_delegate.h"
  21 #include "content/renderer/render_frame_proxy.h"
  22 #include "content/renderer/renderer_webcookiejar_impl.h"
  23 #include "ipc/ipc_message.h"
  24 #include "third_party/WebKit/public/web/WebDataSource.h"
  25 #include "third_party/WebKit/public/web/WebFrameClient.h"
  26 #include "third_party/WebKit/public/web/WebHistoryCommitType.h"
  27 #include "ui/gfx/range/range.h"
  28
  29 #if defined(OS_ANDROID)
  30 #include "content/renderer/media/android/renderer_media_player_manager.h"
  31 #endif
  32
  33 class TransportDIB;
  34 struct FrameMsg_Navigate_Params;
  35
  36 namespace blink {
  37 class WebGeolocationClient;
  38 class WebInputEvent;
  39 class WebMouseEvent;
  40 class WebContentDecryptionModule;
  41 class WebMediaPlayer;
  42 class WebNotificationPresenter;
  43 class WebSecurityOrigin;
  44 struct WebCompositionUnderline;
  45 struct WebContextMenuData;
  46 struct WebCursorInfo;
  47 }
  48
  49 namespace gfx {
  50 class Point;
  51 class Range;
  52 class Rect;
  53 }
  54
  55 namespace content {
  56
  57 class ChildFrameCompositingHelper;
  58 class GeolocationDispatcher;
  59 class MediaStreamRendererFactory;
  60 class MidiDispatcher;
  61 class NotificationProvider;
  62 class PepperPluginInstanceImpl;
  63 class RendererCdmManager;
  64 class RendererMediaPlayerManager;
  65 class RendererPpapiHost;
  66 class RenderFrameObserver;
  67 class RenderViewImpl;
  68 class RenderWidget;
  69 class RenderWidgetFullscreenPepper;
  70 class ScreenOrientationDispatcher;
  71 struct CustomContextMenuContext;
  72
  73 class CONTENT_EXPORT RenderFrameImpl
  74     : public RenderFrame,
  75       NON_EXPORTED_BASE(public blink::WebFrameClient),
  76       NON_EXPORTED_BASE(public WebMediaPlayerDelegate) {
  77  public:
  78   // Creates a new RenderFrame. |render_view| is the RenderView object that this
  79   // frame belongs to.
  80   // Callers *must* call |SetWebFrame| immediately after creation.
  81   // TODO(creis): We should structure this so that |SetWebFrame| isn't needed.
  82   static RenderFrameImpl* Create(RenderViewImpl* render_view, int32 routing_id);
  83
  84   // Returns the RenderFrameImpl for the given routing ID.
  85   static RenderFrameImpl* FromRoutingID(int routing_id);
  86
  87   // Just like RenderFrame::FromWebFrame but returns the implementation.
  88   static RenderFrameImpl* FromWebFrame(blink::WebFrame* web_frame);
  89
  90   // Used by content_layouttest_support to hook into the creation of
  91   // RenderFrameImpls.
  92   static void InstallCreateHook(
  93       RenderFrameImpl* (*create_render_frame_impl)(RenderViewImpl*, int32));
  94
  95   virtual ~RenderFrameImpl();
  96
  97   bool is_swapped_out() const {
  98     return is_swapped_out_;
  99   }
 100
 101   // TODO(nasko): This can be removed once we don't have a swapped out state on
 102   // RenderFrames. See https://crbug.com/357747.
 103   void set_render_frame_proxy(RenderFrameProxy* proxy) {
 104     render_frame_proxy_ = proxy;
 105   }
 106
 107   // Out-of-process child frames receive a signal from RenderWidgetCompositor
 108   // when a compositor frame has committed.
 109   void DidCommitCompositorFrame();
 110
 111   // TODO(jam): this is a temporary getter until all the code is transitioned
 112   // to using RenderFrame instead of RenderView.
 113   RenderViewImpl* render_view() { return render_view_.get(); }
 114
 115   RendererWebCookieJarImpl* cookie_jar() { return &cookie_jar_; }
 116
 117   // Returns the RenderWidget associated with this frame.
 118   RenderWidget* GetRenderWidget();
 119
 120   // This is called right after creation with the WebLocalFrame for this
 121   // RenderFrame. It must be called before Initialize.
 122   void SetWebFrame(blink::WebLocalFrame* web_frame);
 123
 124   // This method must be called after the frame has been added to the frame
 125   // tree. It creates all objects that depend on the frame being at its proper
 126   // spot.
 127   void Initialize();
 128
 129   // Notification from RenderView.
 130   virtual void OnStop();
 131
 132   // Notifications from RenderWidget.
 133   void WasHidden();
 134   void WasShown();
 135
 136   // Start/Stop loading notifications.
 137   // TODO(nasko): Those are page-level methods at this time and come from
 138   // WebViewClient. We should move them to be WebFrameClient calls and put
 139   // logic in the browser side to balance starts/stops.
 140   // |to_different_document| will be true unless the load is a fragment
 141   // navigation, or triggered by history.pushState/replaceState.
 142   virtual void didStartLoading(bool to_different_document);
 143   virtual void didStopLoading();
 144   virtual void didChangeLoadProgress(double load_progress);
 145
 146 #if defined(ENABLE_PLUGINS)
 147   // Notification that a PPAPI plugin has been created.
 148   void PepperPluginCreated(RendererPpapiHost* host);
 149
 150   // Notifies that |instance| has changed the cursor.
 151   // This will update the cursor appearance if it is currently over the plugin
 152   // instance.
 153   void PepperDidChangeCursor(PepperPluginInstanceImpl* instance,
 154                              const blink::WebCursorInfo& cursor);
 155
 156   // Notifies that |instance| has received a mouse event.
 157   void PepperDidReceiveMouseEvent(PepperPluginInstanceImpl* instance);
 158
 159   // Informs the render view that a PPAPI plugin has changed text input status.
 160   void PepperTextInputTypeChanged(PepperPluginInstanceImpl* instance);
 161   void PepperCaretPositionChanged(PepperPluginInstanceImpl* instance);
 162
 163   // Cancels current composition.
 164   void PepperCancelComposition(PepperPluginInstanceImpl* instance);
 165
 166   // Informs the render view that a PPAPI plugin has changed selection.
 167   void PepperSelectionChanged(PepperPluginInstanceImpl* instance);
 168
 169   // Creates a fullscreen container for a pepper plugin instance.
 170   RenderWidgetFullscreenPepper* CreatePepperFullscreenContainer(
 171       PepperPluginInstanceImpl* plugin);
 172
 173   bool IsPepperAcceptingCompositionEvents() const;
 174
 175   // Notification that the given plugin has crashed.
 176   void PluginCrashed(const base::FilePath& plugin_path,
 177                      base::ProcessId plugin_pid);
 178
 179   // Simulates IME events for testing purpose.
 180   void SimulateImeSetComposition(
 181       const base::string16& text,
 182       const std::vector<blink::WebCompositionUnderline>& underlines,
 183       int selection_start,
 184       int selection_end);
 185   void SimulateImeConfirmComposition(const base::string16& text,
 186                                      const gfx::Range& replacement_range);
 187
 188   // TODO(jam): remove these once the IPC handler moves from RenderView to
 189   // RenderFrame.
 190   void OnImeSetComposition(
 191     const base::string16& text,
 192     const std::vector<blink::WebCompositionUnderline>& underlines,
 193     int selection_start,
 194     int selection_end);
 195  void OnImeConfirmComposition(
 196     const base::string16& text,
 197     const gfx::Range& replacement_range,
 198     bool keep_selection);
 199 #endif  // ENABLE_PLUGINS
 200
 201   // IPC::Sender
 202   virtual bool Send(IPC::Message* msg) OVERRIDE;
 203
 204   // IPC::Listener
 205   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 206
 207   // RenderFrame implementation:
 208   virtual RenderView* GetRenderView() OVERRIDE;
 209   virtual int GetRoutingID() OVERRIDE;
 210   virtual blink::WebFrame* GetWebFrame() OVERRIDE;
 211   virtual WebPreferences& GetWebkitPreferences() OVERRIDE;
 212   virtual int ShowContextMenu(ContextMenuClient* client,
 213                               const ContextMenuParams& params) OVERRIDE;
 214   virtual void CancelContextMenu(int request_id) OVERRIDE;
 215   virtual blink::WebNode GetContextMenuNode() const OVERRIDE;
 216   virtual blink::WebPlugin* CreatePlugin(
 217       blink::WebFrame* frame,
 218       const WebPluginInfo& info,
 219       const blink::WebPluginParams& params) OVERRIDE;
 220   virtual void LoadURLExternally(blink::WebLocalFrame* frame,
 221                                  const blink::WebURLRequest& request,
 222                                  blink::WebNavigationPolicy policy) OVERRIDE;
 223   virtual void ExecuteJavaScript(const base::string16& javascript) OVERRIDE;
 224   virtual bool IsHidden() OVERRIDE;
 225
 226   // blink::WebFrameClient implementation:
 227   virtual blink::WebPlugin* createPlugin(blink::WebLocalFrame* frame,
 228                                          const blink::WebPluginParams& params);
 229   virtual blink::WebMediaPlayer* createMediaPlayer(
 230       blink::WebLocalFrame* frame,
 231       const blink::WebURL& url,
 232       blink::WebMediaPlayerClient* client);
 233   virtual blink::WebContentDecryptionModule* createContentDecryptionModule(
 234       blink::WebLocalFrame* frame,
 235       const blink::WebSecurityOrigin& security_origin,
 236       const blink::WebString& key_system);
 237   virtual blink::WebApplicationCacheHost* createApplicationCacheHost(
 238       blink::WebLocalFrame* frame,
 239       blink::WebApplicationCacheHostClient* client);
 240   virtual blink::WebWorkerPermissionClientProxy*
 241       createWorkerPermissionClientProxy(blink::WebLocalFrame* frame);
 242   virtual blink::WebCookieJar* cookieJar(blink::WebLocalFrame* frame);
 243   virtual blink::WebServiceWorkerProvider* createServiceWorkerProvider(
 244       blink::WebLocalFrame* frame);
 245   virtual void didAccessInitialDocument(blink::WebLocalFrame* frame);
 246   virtual blink::WebFrame* createChildFrame(blink::WebLocalFrame* parent,
 247                                             const blink::WebString& name);
 248   virtual void didDisownOpener(blink::WebLocalFrame* frame);
 249   virtual void frameDetached(blink::WebFrame* frame);
 250   virtual void frameFocused();
 251   virtual void willClose(blink::WebFrame* frame);
 252   virtual void didChangeName(blink::WebLocalFrame* frame,
 253                              const blink::WebString& name);
 254   virtual void didMatchCSS(
 255       blink::WebLocalFrame* frame,
 256       const blink::WebVector<blink::WebString>& newly_matching_selectors,
 257       const blink::WebVector<blink::WebString>& stopped_matching_selectors);
 258   virtual bool shouldReportDetailedMessageForSource(
 259       const blink::WebString& source);
 260   virtual void didAddMessageToConsole(const blink::WebConsoleMessage& message,
 261                                       const blink::WebString& source_name,
 262                                       unsigned source_line,
 263                                       const blink::WebString& stack_trace);
 264   virtual void loadURLExternally(blink::WebLocalFrame* frame,
 265                                  const blink::WebURLRequest& request,
 266                                  blink::WebNavigationPolicy policy,
 267                                  const blink::WebString& suggested_name);
 268   // The WebDataSource::ExtraData* is assumed to be a DocumentState* subclass.
 269   virtual blink::WebNavigationPolicy decidePolicyForNavigation(
 270       blink::WebLocalFrame* frame,
 271       blink::WebDataSource::ExtraData* extra_data,
 272       const blink::WebURLRequest& request,
 273       blink::WebNavigationType type,
 274       blink::WebNavigationPolicy default_policy,
 275       bool is_redirect);
 276   virtual blink::WebHistoryItem historyItemForNewChildFrame(
 277       blink::WebFrame* frame);
 278   virtual void willSendSubmitEvent(blink::WebLocalFrame* frame,
 279                                    const blink::WebFormElement& form);
 280   virtual void willSubmitForm(blink::WebLocalFrame* frame,
 281                               const blink::WebFormElement& form);
 282   virtual void didCreateDataSource(blink::WebLocalFrame* frame,
 283                                    blink::WebDataSource* datasource);
 284   virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame);
 285   virtual void didReceiveServerRedirectForProvisionalLoad(
 286       blink::WebLocalFrame* frame);
 287   virtual void didFailProvisionalLoad(
 288       blink::WebLocalFrame* frame,
 289       const blink::WebURLError& error);
 290   virtual void didCommitProvisionalLoad(
 291       blink::WebLocalFrame* frame,
 292       const blink::WebHistoryItem& item,
 293       blink::WebHistoryCommitType commit_type);
 294   virtual void didClearWindowObject(blink::WebLocalFrame* frame);
 295   virtual void didCreateDocumentElement(blink::WebLocalFrame* frame);
 296   virtual void didReceiveTitle(blink::WebLocalFrame* frame,
 297                                const blink::WebString& title,
 298                                blink::WebTextDirection direction);
 299   virtual void didChangeIcon(blink::WebLocalFrame* frame,
 300                              blink::WebIconURL::Type icon_type);
 301   virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame);
 302   virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame);
 303   virtual void didFailLoad(blink::WebLocalFrame* frame,
 304                            const blink::WebURLError& error);
 305   virtual void didFinishLoad(blink::WebLocalFrame* frame);
 306   virtual void didNavigateWithinPage(blink::WebLocalFrame* frame,
 307                                      const blink::WebHistoryItem& item,
 308                                      blink::WebHistoryCommitType commit_type);
 309   virtual void didUpdateCurrentHistoryItem(blink::WebLocalFrame* frame);
 310   virtual void didChangeBrandColor();
 311   virtual blink::WebNotificationPresenter* notificationPresenter();
 312   virtual void didChangeSelection(bool is_empty_selection);
 313   virtual blink::WebColorChooser* createColorChooser(
 314       blink::WebColorChooserClient* client,
 315       const blink::WebColor& initial_color,
 316       const blink::WebVector<blink::WebColorSuggestion>& suggestions);
 317   virtual void runModalAlertDialog(const blink::WebString& message);
 318   virtual bool runModalConfirmDialog(const blink::WebString& message);
 319   virtual bool runModalPromptDialog(const blink::WebString& message,
 320                                     const blink::WebString& default_value,
 321                                     blink::WebString* actual_value);
 322   virtual bool runModalBeforeUnloadDialog(bool is_reload,
 323                                           const blink::WebString& message);
 324   virtual void showContextMenu(const blink::WebContextMenuData& data);
 325   virtual void clearContextMenu();
 326   virtual void willRequestAfterPreconnect(blink::WebLocalFrame* frame,
 327                                           blink::WebURLRequest& request);
 328   virtual void willSendRequest(blink::WebLocalFrame* frame,
 329                                unsigned identifier,
 330                                blink::WebURLRequest& request,
 331                                const blink::WebURLResponse& redirect_response);
 332   virtual void didReceiveResponse(blink::WebLocalFrame* frame,
 333                                   unsigned identifier,
 334                                   const blink::WebURLResponse& response);
 335   virtual void didFinishResourceLoad(blink::WebLocalFrame* frame,
 336                                      unsigned identifier);
 337   virtual void didLoadResourceFromMemoryCache(
 338       blink::WebLocalFrame* frame,
 339       const blink::WebURLRequest& request,
 340       const blink::WebURLResponse& response);
 341   virtual void didDisplayInsecureContent(blink::WebLocalFrame* frame);
 342   virtual void didRunInsecureContent(blink::WebLocalFrame* frame,
 343                                      const blink::WebSecurityOrigin& origin,
 344                                      const blink::WebURL& target);
 345   virtual void didAbortLoading(blink::WebLocalFrame* frame);
 346   virtual void didCreateScriptContext(blink::WebLocalFrame* frame,
 347                                       v8::Handle<v8::Context> context,
 348                                       int extension_group,
 349                                       int world_id);
 350   virtual void willReleaseScriptContext(blink::WebLocalFrame* frame,
 351                                         v8::Handle<v8::Context> context,
 352                                         int world_id);
 353   virtual void didFirstVisuallyNonEmptyLayout(blink::WebLocalFrame* frame);
 354   virtual void didChangeScrollOffset(blink::WebLocalFrame* frame);
 355   virtual void willInsertBody(blink::WebLocalFrame* frame);
 356   virtual void reportFindInPageMatchCount(int request_id,
 357                                           int count,
 358                                           bool final_update);
 359   virtual void reportFindInPageSelection(int request_id,
 360                                          int active_match_ordinal,
 361                                          const blink::WebRect& sel);
 362   virtual void requestStorageQuota(blink::WebLocalFrame* frame,
 363                                    blink::WebStorageQuotaType type,
 364                                    unsigned long long requested_size,
 365                                    blink::WebStorageQuotaCallbacks callbacks);
 366   virtual void willOpenSocketStream(
 367       blink::WebSocketStreamHandle* handle);
 368   virtual void willOpenWebSocket(blink::WebSocketHandle* handle);
 369   virtual blink::WebGeolocationClient* geolocationClient();
 370   virtual void willStartUsingPeerConnectionHandler(
 371       blink::WebLocalFrame* frame,
 372       blink::WebRTCPeerConnectionHandler* handler);
 373   virtual blink::WebUserMediaClient* userMediaClient();
 374   virtual blink::WebMIDIClient* webMIDIClient();
 375   virtual bool willCheckAndDispatchMessageEvent(
 376       blink::WebLocalFrame* source_frame,
 377       blink::WebFrame* target_frame,
 378       blink::WebSecurityOrigin target_origin,
 379       blink::WebDOMMessageEvent event);
 380   virtual blink::WebString userAgentOverride(blink::WebLocalFrame* frame,
 381                                              const blink::WebURL& url);
 382   virtual blink::WebString doNotTrackValue(blink::WebLocalFrame* frame);
 383   virtual bool allowWebGL(blink::WebLocalFrame* frame, bool default_value);
 384   virtual void didLoseWebGLContext(blink::WebLocalFrame* frame,
 385                                    int arb_robustness_status_code);
 386   virtual void forwardInputEvent(const blink::WebInputEvent* event);
 387   virtual void initializeChildFrame(const blink::WebRect& frame_rect,
 388                                     float scale_factor);
 389   virtual blink::WebScreenOrientationClient* webScreenOrientationClient();
 390
 391   // WebMediaPlayerDelegate implementation:
 392   virtual void DidPlay(blink::WebMediaPlayer* player) OVERRIDE;
 393   virtual void DidPause(blink::WebMediaPlayer* player) OVERRIDE;
 394   virtual void PlayerGone(blink::WebMediaPlayer* player) OVERRIDE;
 395
 396   // TODO(nasko): Make all tests in RenderViewImplTest friends and then move
 397   // this back to private member.
 398   void OnNavigate(const FrameMsg_Navigate_Params& params);
 399
 400  protected:
 401   RenderFrameImpl(RenderViewImpl* render_view, int32 routing_id);
 402
 403  private:
 404   friend class RenderFrameObserver;
 405   FRIEND_TEST_ALL_PREFIXES(RendererAccessibilityTest,
 406                            AccessibilityMessagesQueueWhileSwappedOut);
 407   FRIEND_TEST_ALL_PREFIXES(RenderFrameImplTest,
 408                            ShouldUpdateSelectionTextFromContextMenuParams);
 409   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
 410                            OnExtendSelectionAndDelete);
 411   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, ReloadWhileSwappedOut);
 412   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, SendSwapOutACK);
 413   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
 414                            SetEditableSelectionAndComposition);
 415
 416   typedef std::map<GURL, double> HostZoomLevels;
 417
 418   // Functions to add and remove observers for this object.
 419   void AddObserver(RenderFrameObserver* observer);
 420   void RemoveObserver(RenderFrameObserver* observer);
 421
 422   void UpdateURL(blink::WebFrame* frame);
 423
 424   // Gets the focused element. If no such element exists then the element will
 425   // be NULL.
 426   blink::WebElement GetFocusedElement();
 427
 428   // IPC message handlers ------------------------------------------------------
 429   //
 430   // The documentation for these functions should be in
 431   // content/common/*_messages.h for the message that the function is handling.
 432   void OnBeforeUnload();
 433   void OnSwapOut(int proxy_routing_id);
 434   void OnShowContextMenu(const gfx::Point& location);
 435   void OnContextMenuClosed(const CustomContextMenuContext& custom_context);
 436   void OnCustomContextMenuAction(const CustomContextMenuContext& custom_context,
 437                                  unsigned action);
 438   void OnUndo();
 439   void OnRedo();
 440   void OnCut();
 441   void OnCopy();
 442   void OnPaste();
 443   void OnPasteAndMatchStyle();
 444   void OnDelete();
 445   void OnSelectAll();
 446   void OnSelectRange(const gfx::Point& start, const gfx::Point& end);
 447   void OnUnselect();
 448   void OnReplace(const base::string16& text);
 449   void OnReplaceMisspelling(const base::string16& text);
 450   void OnCSSInsertRequest(const std::string& css);
 451   void OnJavaScriptExecuteRequest(const base::string16& javascript,
 452                                   int id,
 453                                   bool notify_result);
 454   void OnSetEditableSelectionOffsets(int start, int end);
 455   void OnSetCompositionFromExistingText(
 456       int start, int end,
 457       const std::vector<blink::WebCompositionUnderline>& underlines);
 458   void OnExtendSelectionAndDelete(int before, int after);
 459   void OnReload(bool ignore_cache);
 460   void OnTextSurroundingSelectionRequest(size_t max_length);
 461   void OnAddStyleSheetByURL(const std::string& url);
 462 #if defined(OS_MACOSX)
 463   void OnCopyToFindPboard();
 464 #endif
 465
 466   // Virtual since overridden by WebTestProxy for layout tests.
 467   virtual blink::WebNavigationPolicy DecidePolicyForNavigation(
 468       RenderFrame* render_frame,
 469       blink::WebFrame* frame,
 470       blink::WebDataSource::ExtraData* extraData,
 471       const blink::WebURLRequest& request,
 472       blink::WebNavigationType type,
 473       blink::WebNavigationPolicy default_policy,
 474       bool is_redirect);
 475   void OpenURL(blink::WebFrame* frame,
 476                const GURL& url,
 477                const Referrer& referrer,
 478                blink::WebNavigationPolicy policy);
 479
 480   // Update current main frame's encoding and send it to browser window.
 481   // Since we want to let users see the right encoding info from menu
 482   // before finishing loading, we call the UpdateEncoding in
 483   // a) function:DidCommitLoadForFrame. When this function is called,
 484   // that means we have got first data. In here we try to get encoding
 485   // of page if it has been specified in http header.
 486   // b) function:DidReceiveTitle. When this function is called,
 487   // that means we have got specified title. Because in most of webpages,
 488   // title tags will follow meta tags. In here we try to get encoding of
 489   // page if it has been specified in meta tag.
 490   // c) function:DidFinishDocumentLoadForFrame. When this function is
 491   // called, that means we have got whole html page. In here we should
 492   // finally get right encoding of page.
 493   void UpdateEncoding(blink::WebFrame* frame,
 494                       const std::string& encoding_name);
 495
 496   // Dispatches the current state of selection on the webpage to the browser if
 497   // it has changed.
 498   // TODO(varunjain): delete this method once we figure out how to keep
 499   // selection handles in sync with the webpage.
 500   void SyncSelectionIfRequired();
 501
 502   // Returns whether |params.selection_text| should be synchronized to the
 503   // browser before bringing up the context menu. Static for testing.
 504   static bool ShouldUpdateSelectionTextFromContextMenuParams(
 505       const base::string16& selection_text,
 506       size_t selection_text_offset,
 507       const gfx::Range& selection_range,
 508       const ContextMenuParams& params);
 509
 510   bool RunJavaScriptMessage(JavaScriptMessageType type,
 511                             const base::string16& message,
 512                             const base::string16& default_value,
 513                             const GURL& frame_url,
 514                             base::string16* result);
 515
 516   // Loads the appropriate error page for the specified failure into the frame.
 517   void LoadNavigationErrorPage(const blink::WebURLRequest& failed_request,
 518                                const blink::WebURLError& error,
 519                                bool replace);
 520
 521   // Initializes |web_user_media_client_|, returning true if successful. Returns
 522   // false if it wasn't possible to create a MediaStreamClient (e.g., WebRTC is
 523   // disabled) in which case |web_user_media_client_| is NULL.
 524   bool InitializeUserMediaClient();
 525
 526   blink::WebMediaPlayer* CreateWebMediaPlayerForMediaStream(
 527       const blink::WebURL& url,
 528       blink::WebMediaPlayerClient* client);
 529
 530   // Creates a factory object used for creating audio and video renderers.
 531   // The method is virtual so that layouttests can override it.
 532   virtual scoped_ptr<MediaStreamRendererFactory> CreateRendererFactory();
 533
 534   // Returns the URL being loaded by the |frame_|'s request.
 535   GURL GetLoadingUrl() const;
 536
 537 #if defined(OS_ANDROID)
 538   blink::WebMediaPlayer* CreateAndroidWebMediaPlayer(
 539       const blink::WebURL& url,
 540       blink::WebMediaPlayerClient* client);
 541
 542   RendererMediaPlayerManager* GetMediaPlayerManager();
 543 #endif
 544
 545 #if defined(ENABLE_BROWSER_CDMS)
 546   RendererCdmManager* GetCdmManager();
 547 #endif
 548
 549   // Stores the WebLocalFrame we are associated with.
 550   blink::WebLocalFrame* frame_;
 551
 552   base::WeakPtr<RenderViewImpl> render_view_;
 553   int routing_id_;
 554   bool is_swapped_out_;
 555   // RenderFrameProxy exists only when is_swapped_out_ is true.
 556   // TODO(nasko): This can be removed once we don't have a swapped out state on
 557   // RenderFrame. See https://crbug.com/357747.
 558   RenderFrameProxy* render_frame_proxy_;
 559   bool is_detaching_;
 560
 561 #if defined(ENABLE_PLUGINS)
 562   // Current text input composition text. Empty if no composition is in
 563   // progress.
 564   base::string16 pepper_composition_text_;
 565 #endif
 566
 567   RendererWebCookieJarImpl cookie_jar_;
 568
 569   // All the registered observers.
 570   ObserverList<RenderFrameObserver> observers_;
 571
 572   scoped_refptr<ChildFrameCompositingHelper> compositing_helper_;
 573
 574   // The node that the context menu was pressed over.
 575   blink::WebNode context_menu_node_;
 576
 577   // External context menu requests we're waiting for. "Internal"
 578   // (WebKit-originated) context menu events will have an ID of 0 and will not
 579   // be in this map.
 580   //
 581   // We don't want to add internal ones since some of the "special" page
 582   // handlers in the browser process just ignore the context menu requests so
 583   // avoid showing context menus, and so this will cause right clicks to leak
 584   // entries in this map. Most users of the custom context menu (e.g. Pepper
 585   // plugins) are normally only on "regular" pages and the regular pages will
 586   // always respond properly to the request, so we don't have to worry so
 587   // much about leaks.
 588   IDMap<ContextMenuClient, IDMapExternalPointer> pending_context_menus_;
 589
 590   // The text selection the last time DidChangeSelection got called. May contain
 591   // additional characters before and after the selected text, for IMEs. The
 592   // portion of this string that is the actual selected text starts at index
 593   // |selection_range_.GetMin() - selection_text_offset_| and has length
 594   // |selection_range_.length()|.
 595   base::string16 selection_text_;
 596   // The offset corresponding to the start of |selection_text_| in the document.
 597   size_t selection_text_offset_;
 598   // Range over the document corresponding to the actual selected text (which
 599   // could correspond to a substring of |selection_text_|; see above).
 600   gfx::Range selection_range_;
 601   // Used to inform didChangeSelection() when it is called in the context
 602   // of handling a InputMsg_SelectRange IPC.
 603   bool handling_select_range_;
 604
 605   // The next group of objects all implement RenderFrameObserver, so are deleted
 606   // along with the RenderFrame automatically.  This is why we just store weak
 607   // references.
 608
 609   // Holds a reference to the service which provides desktop notifications.
 610   NotificationProvider* notification_provider_;
 611
 612   blink::WebUserMediaClient* web_user_media_client_;
 613
 614   // MidiClient attached to this frame; lazily initialized.
 615   MidiDispatcher* midi_dispatcher_;
 616
 617 #if defined(OS_ANDROID)
 618   // Manages all media players in this render frame for communicating with the
 619   // real media player in the browser process. It's okay to use a raw pointer
 620   // since it's a RenderFrameObserver.
 621   RendererMediaPlayerManager* media_player_manager_;
 622 #endif
 623
 624 #if defined(ENABLE_BROWSER_CDMS)
 625   // Manage all CDMs in this render frame for communicating with the real CDM in
 626   // the browser process. It's okay to use a raw pointer since it's a
 627   // RenderFrameObserver.
 628   RendererCdmManager* cdm_manager_;
 629 #endif
 630
 631   // The geolocation dispatcher attached to this view, lazily initialized.
 632   GeolocationDispatcher* geolocation_dispatcher_;
 633
 634   // The screen orientation dispatcher attached to the view, lazily initialized.
 635   ScreenOrientationDispatcher* screen_orientation_dispatcher_;
 636
 637   base::WeakPtrFactory<RenderFrameImpl> weak_factory_;
 638
 639   DISALLOW_COPY_AND_ASSIGN(RenderFrameImpl);
 640 };
 641
 642 }  // namespace content
 643
 644 #endif  // CONTENT_RENDERER_RENDER_FRAME_IMPL_H_