Home | History | Annotate | Download | only in renderer 
      1 // Copyright (c) 2012 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_VIEW_IMPL_H_
      6 #define CONTENT_RENDERER_RENDER_VIEW_IMPL_H_
      7 
      8 #include <deque>
      9 #include <map>
     10 #include <set>
     11 #include <string>
     12 #include <vector>
     13 
     14 #include "base/basictypes.h"
     15 #include "base/gtest_prod_util.h"
     16 #include "base/id_map.h"
     17 #include "base/memory/linked_ptr.h"
     18 #include "base/memory/weak_ptr.h"
     19 #include "base/observer_list.h"
     20 #include "base/process/process.h"
     21 #include "base/strings/string16.h"
     22 #include "base/timer/timer.h"
     23 #include "build/build_config.h"
     24 #include "cc/input/top_controls_state.h"
     25 #include "content/common/content_export.h"
     26 #include "content/common/drag_event_source_info.h"
     27 #include "content/common/edit_command.h"
     28 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
     29 #include "content/common/navigation_gesture.h"
     30 #include "content/common/view_message_enums.h"
     31 #include "content/public/common/javascript_message_type.h"
     32 #include "content/public/common/page_zoom.h"
     33 #include "content/public/common/referrer.h"
     34 #include "content/public/common/renderer_preferences.h"
     35 #include "content/public/common/stop_find_action.h"
     36 #include "content/public/common/top_controls_state.h"
     37 #include "content/public/renderer/render_view.h"
     38 #include "content/renderer/media/webmediaplayer_delegate.h"
     39 #include "content/renderer/mouse_lock_dispatcher.h"
     40 #include "content/renderer/render_frame_impl.h"
     41 #include "content/renderer/render_widget.h"
     42 #include "content/renderer/renderer_date_time_picker.h"
     43 #include "content/renderer/renderer_webcookiejar_impl.h"
     44 #include "content/renderer/stats_collection_observer.h"
     45 #include "ipc/ipc_platform_file.h"
     46 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
     47 #include "third_party/WebKit/public/web/WebAXObject.h"
     48 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
     49 #include "third_party/WebKit/public/web/WebDataSource.h"
     50 #include "third_party/WebKit/public/web/WebFrameClient.h"
     51 #include "third_party/WebKit/public/web/WebHistoryItem.h"
     52 #include "third_party/WebKit/public/web/WebIconURL.h"
     53 #include "third_party/WebKit/public/web/WebInputEvent.h"
     54 #include "third_party/WebKit/public/web/WebNavigationType.h"
     55 #include "third_party/WebKit/public/web/WebNode.h"
     56 #include "third_party/WebKit/public/web/WebPageSerializerClient.h"
     57 #include "third_party/WebKit/public/web/WebPageVisibilityState.h"
     58 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
     59 #include "third_party/WebKit/public/web/WebViewClient.h"
     60 #include "ui/base/ui_base_types.h"
     61 #include "ui/surface/transport_dib.h"
     62 #include "webkit/common/webpreferences.h"
     63 
     64 #if defined(OS_ANDROID)
     65 #include "content/renderer/android/content_detector.h"
     66 #include "third_party/WebKit/public/web/WebContentDetectionResult.h"
     67 #endif
     68 
     69 #if defined(COMPILER_MSVC)
     70 // RenderViewImpl is a diamond-shaped hierarchy, with WebWidgetClient at the
     71 // root. VS warns when we inherit the WebWidgetClient method implementations
     72 // from RenderWidget.  It's safe to ignore that warning.
     73 #pragma warning(disable: 4250)
     74 #endif
     75 
     76 class CommandLine;
     77 class PepperDeviceTest;
     78 class SkBitmap;
     79 struct PP_NetAddress_Private;
     80 struct ViewMsg_Navigate_Params;
     81 struct ViewMsg_PostMessage_Params;
     82 struct ViewMsg_StopFinding_Params;
     83 
     84 namespace ui {
     85 struct SelectedFileInfo;
     86 }  // namespace ui
     87 
     88 namespace blink {
     89 class WebApplicationCacheHost;
     90 class WebApplicationCacheHostClient;
     91 class WebDOMMessageEvent;
     92 class WebDataSource;
     93 class WebDateTimeChooserCompletion;
     94 class WebDragData;
     95 class WebGeolocationClient;
     96 class WebGestureEvent;
     97 class WebIconURL;
     98 class WebImage;
     99 class WebPeerConnection00Handler;
    100 class WebPeerConnection00HandlerClient;
    101 class WebMediaPlayer;
    102 class WebMediaPlayerClient;
    103 class WebMouseEvent;
    104 class WebPeerConnectionHandler;
    105 class WebPeerConnectionHandlerClient;
    106 class WebSocketStreamHandle;
    107 class WebSpeechInputController;
    108 class WebSpeechInputListener;
    109 class WebSpeechRecognizer;
    110 class WebStorageNamespace;
    111 class WebTouchEvent;
    112 class WebURLRequest;
    113 class WebUserMediaClient;
    114 struct WebActiveWheelFlingParameters;
    115 struct WebDateTimeChooserParams;
    116 struct WebFileChooserParams;
    117 struct WebFindOptions;
    118 struct WebMediaPlayerAction;
    119 struct WebPluginAction;
    120 struct WebPoint;
    121 struct WebWindowFeatures;
    122 
    123 #if defined(OS_ANDROID)
    124 class WebHitTestResult;
    125 #endif
    126 }
    127 
    128 namespace webkit_glue {
    129 class WebURLResponseExtraDataImpl;
    130 }
    131 
    132 namespace content {
    133 class BrowserPluginManager;
    134 class DeviceOrientationDispatcher;
    135 class DevToolsAgent;
    136 class DocumentState;
    137 class DomAutomationController;
    138 class ExternalPopupMenu;
    139 class FaviconHelper;
    140 class GeolocationDispatcher;
    141 class ImageResourceFetcher;
    142 class InputTagSpeechDispatcher;
    143 class JavaBridgeDispatcher;
    144 class LoadProgressTracker;
    145 class MIDIDispatcher;
    146 class MediaStreamClient;
    147 class MediaStreamDispatcher;
    148 class MouseLockDispatcher;
    149 class NavigationState;
    150 class NotificationProvider;
    151 class PepperPluginInstanceImpl;
    152 class RenderViewObserver;
    153 class RenderViewTest;
    154 class RendererAccessibility;
    155 class RendererDateTimePicker;
    156 class RendererWebColorChooserImpl;
    157 class SpeechRecognitionDispatcher;
    158 class WebPluginDelegateProxy;
    159 struct CustomContextMenuContext;
    160 struct DropData;
    161 struct FaviconURL;
    162 struct FileChooserParams;
    163 struct RenderViewImplParams;
    164 
    165 #if defined(OS_ANDROID)
    166 class RendererMediaPlayerManager;
    167 class WebMediaPlayerProxyAndroid;
    168 #endif
    169 
    170 //
    171 // RenderView is an object that manages a WebView object, and provides a
    172 // communication interface with an embedding application process
    173 //
    174 class CONTENT_EXPORT RenderViewImpl
    175     : public RenderWidget,
    176       NON_EXPORTED_BASE(public blink::WebViewClient),
    177       NON_EXPORTED_BASE(public blink::WebFrameClient),
    178       NON_EXPORTED_BASE(public blink::WebPageSerializerClient),
    179       public RenderView,
    180       NON_EXPORTED_BASE(public WebMediaPlayerDelegate),
    181       public base::SupportsWeakPtr<RenderViewImpl> {
    182  public:
    183   // Creates a new RenderView. |opener_id| is the routing ID of the RenderView
    184   // responsible for creating this RenderView.
    185   static RenderViewImpl* Create(
    186       int32 opener_id,
    187       const RendererPreferences& renderer_prefs,
    188       const WebPreferences& webkit_prefs,
    189       int32 routing_id,
    190       int32 main_frame_routing_id,
    191       int32 surface_id,
    192       int64 session_storage_namespace_id,
    193       const base::string16& frame_name,
    194       bool is_renderer_created,
    195       bool swapped_out,
    196       bool hidden,
    197       int32 next_page_id,
    198       const blink::WebScreenInfo& screen_info,
    199       AccessibilityMode accessibility_mode,
    200       bool allow_partial_swap);
    201 
    202   // Used by content_layouttest_support to hook into the creation of
    203   // RenderViewImpls.
    204   static void InstallCreateHook(
    205       RenderViewImpl* (*create_render_view_impl)(RenderViewImplParams*));
    206 
    207   // Returns the RenderViewImpl containing the given WebView.
    208   static RenderViewImpl* FromWebView(blink::WebView* webview);
    209 
    210   // Returns the RenderViewImpl for the given routing ID.
    211   static RenderViewImpl* FromRoutingID(int routing_id);
    212 
    213   // May return NULL when the view is closing.
    214   blink::WebView* webview() const;
    215 
    216   int history_list_offset() const { return history_list_offset_; }
    217 
    218   const WebPreferences& webkit_preferences() const {
    219     return webkit_preferences_;
    220   }
    221 
    222   const RendererPreferences& renderer_preferences() const {
    223     return renderer_preferences_;
    224   }
    225 
    226   void set_send_content_state_immediately(bool value) {
    227     send_content_state_immediately_ = value;
    228   }
    229 
    230   RenderFrameImpl* main_render_frame() { return main_render_frame_.get(); }
    231 
    232   MediaStreamDispatcher* media_stream_dispatcher() {
    233     return media_stream_dispatcher_;
    234   }
    235 
    236   RendererAccessibility* renderer_accessibility() {
    237     return renderer_accessibility_;
    238   }
    239 
    240   MouseLockDispatcher* mouse_lock_dispatcher() {
    241     return mouse_lock_dispatcher_;
    242   }
    243 
    244   RendererWebCookieJarImpl* cookie_jar() { return &cookie_jar_; }
    245 
    246   // Lazily initialize this view's BrowserPluginManager and return it.
    247   BrowserPluginManager* GetBrowserPluginManager();
    248 
    249   // Functions to add and remove observers for this object.
    250   void AddObserver(RenderViewObserver* observer);
    251   void RemoveObserver(RenderViewObserver* observer);
    252 
    253   // Returns the StatsCollectionObserver associated with this view, or NULL
    254   // if one wasn't created;
    255   StatsCollectionObserver* GetStatsCollectionObserver() {
    256     return stats_collection_observer_.get();
    257   }
    258 
    259   // Adds the given file chooser request to the file_chooser_completion_ queue
    260   // (see that var for more) and requests the chooser be displayed if there are
    261   // no other waiting items in the queue.
    262   //
    263   // Returns true if the chooser was successfully scheduled. False means we
    264   // didn't schedule anything.
    265   bool ScheduleFileChooser(const FileChooserParams& params,
    266                            blink::WebFileChooserCompletion* completion);
    267 
    268   void LoadNavigationErrorPage(
    269       blink::WebFrame* frame,
    270       const blink::WebURLRequest& failed_request,
    271       const blink::WebURLError& error,
    272       const std::string& html,
    273       bool replace);
    274 
    275 #if defined(OS_ANDROID)
    276   void DismissDateTimeDialog();
    277 #endif
    278 
    279   // Plugin-related functions --------------------------------------------------
    280 
    281 #if defined(ENABLE_PLUGINS)
    282   PepperPluginInstanceImpl* focused_pepper_plugin() {
    283     return focused_pepper_plugin_;
    284   }
    285   void set_focused_pepper_plugin(PepperPluginInstanceImpl* plugin) {
    286     focused_pepper_plugin_ = plugin;
    287   }
    288   PepperPluginInstanceImpl* pepper_last_mouse_event_target() {
    289     return pepper_last_mouse_event_target_;
    290   }
    291   void set_pepper_last_mouse_event_target(PepperPluginInstanceImpl* plugin) {
    292     pepper_last_mouse_event_target_ = plugin;
    293   }
    294 
    295 #if defined(OS_MACOSX) || defined(OS_WIN)
    296   // Informs the render view that the given plugin has gained or lost focus.
    297   void PluginFocusChanged(bool focused, int plugin_id);
    298 #endif
    299 
    300 #if defined(OS_MACOSX)
    301   // Starts plugin IME.
    302   void StartPluginIme();
    303 #endif
    304 
    305   void RegisterPluginDelegate(WebPluginDelegateProxy* delegate);
    306   void UnregisterPluginDelegate(WebPluginDelegateProxy* delegate);
    307 #endif  // ENABLE_PLUGINS
    308 
    309   void TransferActiveWheelFlingAnimation(
    310       const blink::WebActiveWheelFlingParameters& params);
    311 
    312   // Returns true if the focused element is editable text from the perspective
    313   // of IME support (also used for on-screen keyboard). Works correctly inside
    314   // supported PPAPI plug-ins.
    315   bool HasIMETextFocus();
    316 
    317   // Callback for use with GetWindowSnapshot.
    318   typedef base::Callback<void(
    319       const gfx::Size&, const std::vector<unsigned char>&)>
    320       WindowSnapshotCallback;
    321 
    322   void GetWindowSnapshot(const WindowSnapshotCallback& callback);
    323 
    324   // Dispatches the current navigation state to the browser. Called on a
    325   // periodic timer so we don't send too many messages.
    326   void SyncNavigationState();
    327 
    328   // Temporary call until all this media code moves to RenderFrame.
    329   // TODO(jam): remove me
    330   blink::WebMediaPlayer* CreateMediaPlayer(
    331       RenderFrame* render_frame,
    332       blink::WebFrame* frame,
    333       const blink::WebURL& url,
    334       blink::WebMediaPlayerClient* client);
    335   // Temporary call until the context menu code moves to RenderFrmae.
    336   // TODO(jam): remove me
    337   int ShowContextMenu(ContextMenuClient* client,
    338                       const ContextMenuParams& params);
    339   void CancelContextMenu(int request_id);
    340 
    341   // Returns the length of the session history of this RenderView. Note that
    342   // this only coincides with the actual length of the session history if this
    343   // RenderView is the currently active RenderView of a WebContents.
    344   unsigned GetLocalSessionHistoryLengthForTesting() const;
    345 
    346   // Invokes OnSetFocus and marks the widget as active depending on the value
    347   // of |enable|. This is used for layout tests that need to control the focus
    348   // synchronously from the renderer.
    349   void SetFocusAndActivateForTesting(bool enable);
    350 
    351   // Change the device scale factor and force the compositor to resize.
    352   void SetDeviceScaleFactorForTesting(float factor);
    353 
    354   // Used to force the size of a window when running layout tests.
    355   void ForceResizeForTesting(const gfx::Size& new_size);
    356 
    357   void UseSynchronousResizeModeForTesting(bool enable);
    358 
    359   // Control autoresize mode.
    360   void EnableAutoResizeForTesting(const gfx::Size& min_size,
    361                                   const gfx::Size& max_size);
    362   void DisableAutoResizeForTesting(const gfx::Size& new_size);
    363 
    364   // Overrides the MediaStreamClient used when creating MediaStream players.
    365   // Must be called before any players are created.
    366   void SetMediaStreamClientForTesting(MediaStreamClient* media_stream_client);
    367 
    368   // IPC::Listener implementation ----------------------------------------------
    369 
    370   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
    371 
    372   // blink::WebWidgetClient implementation ------------------------------------
    373 
    374   // Most methods are handled by RenderWidget.
    375   virtual void didFocus();
    376   virtual void didBlur();
    377   virtual void show(blink::WebNavigationPolicy policy);
    378   virtual void runModal();
    379   virtual bool enterFullScreen();
    380   virtual void exitFullScreen();
    381   virtual bool requestPointerLock();
    382   virtual void requestPointerUnlock();
    383   virtual bool isPointerLocked();
    384   virtual void didActivateCompositor(int input_handler_identifier);
    385   virtual void didHandleGestureEvent(const blink::WebGestureEvent& event,
    386                                      bool event_cancelled) OVERRIDE;
    387   virtual void initializeLayerTreeView() OVERRIDE;
    388 
    389   // blink::WebViewClient implementation --------------------------------------
    390 
    391   virtual blink::WebView* createView(
    392       blink::WebFrame* creator,
    393       const blink::WebURLRequest& request,
    394       const blink::WebWindowFeatures& features,
    395       const blink::WebString& frame_name,
    396       blink::WebNavigationPolicy policy,
    397       bool suppress_opener);
    398   virtual blink::WebWidget* createPopupMenu(blink::WebPopupType popup_type);
    399   virtual blink::WebExternalPopupMenu* createExternalPopupMenu(
    400       const blink::WebPopupMenuInfo& popup_menu_info,
    401       blink::WebExternalPopupMenuClient* popup_menu_client);
    402   virtual blink::WebStorageNamespace* createSessionStorageNamespace();
    403   virtual bool shouldReportDetailedMessageForSource(
    404       const blink::WebString& source);
    405   virtual void didAddMessageToConsole(
    406       const blink::WebConsoleMessage& message,
    407       const blink::WebString& source_name,
    408       unsigned source_line,
    409       const blink::WebString& stack_trace);
    410   virtual void printPage(blink::WebFrame* frame);
    411   virtual blink::WebNotificationPresenter* notificationPresenter();
    412   virtual bool enumerateChosenDirectory(
    413       const blink::WebString& path,
    414       blink::WebFileChooserCompletion* chooser_completion);
    415   virtual void initializeHelperPluginWebFrame(blink::WebHelperPlugin*);
    416   virtual void didStartLoading();
    417   virtual void didStopLoading();
    418   virtual void didChangeLoadProgress(blink::WebFrame* frame,
    419                                      double load_progress);
    420   virtual void didCancelCompositionOnSelectionChange();
    421   virtual void didChangeSelection(bool is_selection_empty);
    422   virtual void didExecuteCommand(const blink::WebString& command_name);
    423   virtual bool handleCurrentKeyboardEvent();
    424   virtual blink::WebColorChooser* createColorChooser(
    425       blink::WebColorChooserClient*,
    426       const blink::WebColor& initial_color,
    427       const blink::WebVector<blink::WebColorSuggestion>& suggestions);
    428   virtual bool runFileChooser(
    429       const blink::WebFileChooserParams& params,
    430       blink::WebFileChooserCompletion* chooser_completion);
    431   virtual void runModalAlertDialog(blink::WebFrame* frame,
    432                                    const blink::WebString& message);
    433   virtual bool runModalConfirmDialog(blink::WebFrame* frame,
    434                                      const blink::WebString& message);
    435   virtual bool runModalPromptDialog(blink::WebFrame* frame,
    436                                     const blink::WebString& message,
    437                                     const blink::WebString& default_value,
    438                                     blink::WebString* actual_value);
    439   virtual bool runModalBeforeUnloadDialog(blink::WebFrame* frame,
    440                                           bool is_reload,
    441                                           const blink::WebString& message);
    442   virtual void showValidationMessage(const blink::WebRect& anchor_in_root_view,
    443                                      const blink::WebString& main_text,
    444                                      const blink::WebString& sub_text,
    445                                      blink::WebTextDirection hint) OVERRIDE;
    446   virtual void hideValidationMessage() OVERRIDE;
    447   virtual void moveValidationMessage(
    448       const blink::WebRect& anchor_in_root_view) OVERRIDE;
    449 
    450   // DEPRECATED
    451   virtual bool runModalBeforeUnloadDialog(blink::WebFrame* frame,
    452                                           const blink::WebString& message);
    453   virtual void showContextMenu(blink::WebFrame* frame,
    454                                const blink::WebContextMenuData& data);
    455   virtual void clearContextMenu();
    456   virtual void setStatusText(const blink::WebString& text);
    457   virtual void setMouseOverURL(const blink::WebURL& url);
    458   virtual void setKeyboardFocusURL(const blink::WebURL& url);
    459   virtual void startDragging(blink::WebFrame* frame,
    460                              const blink::WebDragData& data,
    461                              blink::WebDragOperationsMask mask,
    462                              const blink::WebImage& image,
    463                              const blink::WebPoint& imageOffset);
    464   virtual bool acceptsLoadDrops();
    465   virtual void focusNext();
    466   virtual void focusPrevious();
    467   virtual void focusedNodeChanged(const blink::WebNode& node);
    468   virtual void numberOfWheelEventHandlersChanged(unsigned num_handlers);
    469   virtual void didUpdateLayout();
    470 #if defined(OS_ANDROID)
    471   virtual bool didTapMultipleTargets(
    472       const blink::WebGestureEvent& event,
    473       const blink::WebVector<blink::WebRect>& target_rects);
    474 #endif
    475   virtual void navigateBackForwardSoon(int offset);
    476   virtual int historyBackListCount();
    477   virtual int historyForwardListCount();
    478   virtual void postAccessibilityEvent(
    479       const blink::WebAXObject& obj, blink::WebAXEvent event);
    480   virtual void didUpdateInspectorSetting(const blink::WebString& key,
    481                                          const blink::WebString& value);
    482   virtual blink::WebGeolocationClient* geolocationClient();
    483   virtual blink::WebSpeechInputController* speechInputController(
    484       blink::WebSpeechInputListener* listener);
    485   virtual blink::WebSpeechRecognizer* speechRecognizer();
    486   virtual void zoomLimitsChanged(double minimum_level, double maximum_level);
    487   virtual void zoomLevelChanged();
    488   virtual double zoomLevelToZoomFactor(double zoom_level) const;
    489   virtual double zoomFactorToZoomLevel(double factor) const;
    490   virtual void registerProtocolHandler(const blink::WebString& scheme,
    491                                        const blink::WebString& base_url,
    492                                        const blink::WebString& url,
    493                                        const blink::WebString& title);
    494   virtual blink::WebPageVisibilityState visibilityState() const;
    495   virtual blink::WebUserMediaClient* userMediaClient();
    496   virtual blink::WebMIDIClient* webMIDIClient();
    497   virtual void draggableRegionsChanged();
    498 
    499 #if defined(OS_ANDROID)
    500   virtual void scheduleContentIntent(const blink::WebURL& intent);
    501   virtual void cancelScheduledContentIntents();
    502   virtual blink::WebContentDetectionResult detectContentAround(
    503       const blink::WebHitTestResult& touch_hit);
    504 
    505   // Only used on Android since all other platforms implement
    506   // date and time input fields using MULTIPLE_FIELDS_UI
    507   virtual bool openDateTimeChooser(const blink::WebDateTimeChooserParams&,
    508                                    blink::WebDateTimeChooserCompletion*);
    509   virtual void didScrollWithKeyboard(const blink::WebSize& delta);
    510 #endif
    511 
    512   // blink::WebFrameClient implementation -------------------------------------
    513 
    514   virtual blink::WebMediaPlayer* createMediaPlayer(
    515       blink::WebFrame* frame,
    516       const blink::WebURL& url,
    517       blink::WebMediaPlayerClient* client);
    518   virtual blink::WebCookieJar* cookieJar(blink::WebFrame* frame);
    519   virtual void didAccessInitialDocument(blink::WebFrame* frame);
    520   virtual void didDisownOpener(blink::WebFrame* frame);
    521   virtual void frameDetached(blink::WebFrame* frame);
    522   virtual void willClose(blink::WebFrame* frame);
    523   virtual void didMatchCSS(
    524       blink::WebFrame* frame,
    525       const blink::WebVector<blink::WebString>& newly_matching_selectors,
    526       const blink::WebVector<blink::WebString>& stopped_matching_selectors);
    527 
    528   // The WebDataSource::ExtraData* is assumed to be a DocumentState* subclass.
    529   virtual blink::WebNavigationPolicy decidePolicyForNavigation(
    530       blink::WebFrame* frame,
    531       blink::WebDataSource::ExtraData* extraData,
    532       const blink::WebURLRequest& request,
    533       blink::WebNavigationType type,
    534       blink::WebNavigationPolicy default_policy,
    535       bool is_redirect);
    536   // DEPRECATED.
    537   virtual blink::WebNavigationPolicy decidePolicyForNavigation(
    538       blink::WebFrame* frame,
    539       const blink::WebURLRequest& request,
    540       blink::WebNavigationType type,
    541       blink::WebNavigationPolicy default_policy,
    542       bool is_redirect);
    543   virtual void willSendSubmitEvent(blink::WebFrame* frame,
    544                                    const blink::WebFormElement& form);
    545   virtual void willSubmitForm(blink::WebFrame* frame,
    546                               const blink::WebFormElement& form);
    547   virtual void didCreateDataSource(blink::WebFrame* frame,
    548                                    blink::WebDataSource* datasource);
    549   virtual void didStartProvisionalLoad(blink::WebFrame* frame);
    550   virtual void didReceiveServerRedirectForProvisionalLoad(
    551       blink::WebFrame* frame);
    552   virtual void didFailProvisionalLoad(blink::WebFrame* frame,
    553                                       const blink::WebURLError& error);
    554   virtual void didCommitProvisionalLoad(blink::WebFrame* frame,
    555                                         bool is_new_navigation);
    556   virtual void didClearWindowObject(blink::WebFrame* frame);
    557   virtual void didCreateDocumentElement(blink::WebFrame* frame);
    558   virtual void didReceiveTitle(blink::WebFrame* frame,
    559                                const blink::WebString& title,
    560                                blink::WebTextDirection direction);
    561   virtual void didChangeIcon(blink::WebFrame*,
    562                              blink::WebIconURL::Type);
    563   virtual void didFinishDocumentLoad(blink::WebFrame* frame);
    564   virtual void didHandleOnloadEvents(blink::WebFrame* frame);
    565   virtual void didFailLoad(blink::WebFrame* frame,
    566                            const blink::WebURLError& error);
    567   virtual void didFinishLoad(blink::WebFrame* frame);
    568   virtual void didNavigateWithinPage(blink::WebFrame* frame,
    569                                      bool is_new_navigation);
    570   virtual void didUpdateCurrentHistoryItem(blink::WebFrame* frame);
    571   virtual void willSendRequest(blink::WebFrame* frame,
    572                                unsigned identifier,
    573                                blink::WebURLRequest& request,
    574                                const blink::WebURLResponse& redirect_response);
    575   virtual void didReceiveResponse(blink::WebFrame* frame,
    576                                   unsigned identifier,
    577                                   const blink::WebURLResponse& response);
    578   virtual void didFinishResourceLoad(blink::WebFrame* frame,
    579                                      unsigned identifier);
    580   virtual void didLoadResourceFromMemoryCache(
    581       blink::WebFrame* frame,
    582       const blink::WebURLRequest& request,
    583       const blink::WebURLResponse&);
    584   virtual void didDisplayInsecureContent(blink::WebFrame* frame);
    585   virtual void didRunInsecureContent(
    586       blink::WebFrame* frame,
    587       const blink::WebSecurityOrigin& origin,
    588       const blink::WebURL& target);
    589   virtual void didExhaustMemoryAvailableForScript(blink::WebFrame* frame);
    590   virtual void didCreateScriptContext(blink::WebFrame* frame,
    591                                       v8::Handle<v8::Context>,
    592                                       int extension_group,
    593                                       int world_id);
    594   virtual void willReleaseScriptContext(blink::WebFrame* frame,
    595                                         v8::Handle<v8::Context>,
    596                                         int world_id);
    597   virtual void didChangeScrollOffset(blink::WebFrame* frame);
    598   virtual void willInsertBody(blink::WebFrame* frame);
    599   virtual void didFirstVisuallyNonEmptyLayout(blink::WebFrame*);
    600   virtual void didChangeContentsSize(blink::WebFrame* frame,
    601                                      const blink::WebSize& size);
    602   virtual void reportFindInPageMatchCount(int request_id,
    603                                           int count,
    604                                           bool final_update);
    605   virtual void reportFindInPageSelection(int request_id,
    606                                          int active_match_ordinal,
    607                                          const blink::WebRect& sel);
    608   virtual void requestStorageQuota(
    609       blink::WebFrame* frame,
    610       blink::WebStorageQuotaType type,
    611       unsigned long long requested_size,
    612       blink::WebStorageQuotaCallbacks* callbacks);
    613   virtual void willOpenSocketStream(
    614       blink::WebSocketStreamHandle* handle);
    615   virtual void willStartUsingPeerConnectionHandler(blink::WebFrame* frame,
    616       blink::WebRTCPeerConnectionHandler* handler);
    617   virtual bool willCheckAndDispatchMessageEvent(
    618       blink::WebFrame* sourceFrame,
    619       blink::WebFrame* targetFrame,
    620       blink::WebSecurityOrigin targetOrigin,
    621       blink::WebDOMMessageEvent event);
    622   virtual blink::WebString acceptLanguages();
    623   virtual blink::WebString userAgentOverride(
    624       blink::WebFrame* frame,
    625       const blink::WebURL& url);
    626   virtual blink::WebString doNotTrackValue(blink::WebFrame* frame);
    627   virtual bool allowWebGL(blink::WebFrame* frame, bool default_value);
    628   virtual void didLoseWebGLContext(
    629       blink::WebFrame* frame,
    630       int arb_robustness_status_code);
    631 
    632   // blink::WebPageSerializerClient implementation ----------------------------
    633 
    634   virtual void didSerializeDataForFrame(
    635       const blink::WebURL& frame_url,
    636       const blink::WebCString& data,
    637       PageSerializationStatus status) OVERRIDE;
    638 
    639   // RenderView implementation -------------------------------------------------
    640 
    641   virtual bool Send(IPC::Message* message) OVERRIDE;
    642   virtual RenderFrame* GetMainRenderFrame() OVERRIDE;
    643   virtual int GetRoutingID() const OVERRIDE;
    644   virtual int GetPageId() const OVERRIDE;
    645   virtual gfx::Size GetSize() const OVERRIDE;
    646   virtual WebPreferences& GetWebkitPreferences() OVERRIDE;
    647   virtual void SetWebkitPreferences(const WebPreferences& preferences) OVERRIDE;
    648   virtual blink::WebView* GetWebView() OVERRIDE;
    649   virtual blink::WebNode GetFocusedNode() const OVERRIDE;
    650   virtual blink::WebNode GetContextMenuNode() const OVERRIDE;
    651   virtual bool IsEditableNode(const blink::WebNode& node) const OVERRIDE;
    652   virtual void EvaluateScript(const base::string16& frame_xpath,
    653                               const base::string16& jscript,
    654                               int id,
    655                               bool notify_result) OVERRIDE;
    656   virtual bool ShouldDisplayScrollbars(int width, int height) const OVERRIDE;
    657   virtual int GetEnabledBindings() const OVERRIDE;
    658   virtual bool GetContentStateImmediately() const OVERRIDE;
    659   virtual float GetFilteredTimePerFrame() const OVERRIDE;
    660   virtual blink::WebPageVisibilityState GetVisibilityState() const OVERRIDE;
    661   virtual void RunModalAlertDialog(blink::WebFrame* frame,
    662                                    const blink::WebString& message) OVERRIDE;
    663   virtual void DidStartLoading() OVERRIDE;
    664   virtual void DidStopLoading() OVERRIDE;
    665   virtual void Repaint(const gfx::Size& size) OVERRIDE;
    666   virtual void SetEditCommandForNextKeyEvent(const std::string& name,
    667                                              const std::string& value) OVERRIDE;
    668   virtual void ClearEditCommands() OVERRIDE;
    669   virtual SSLStatus GetSSLStatusOfFrame(blink::WebFrame* frame) const OVERRIDE;
    670   virtual const std::string& GetAcceptLanguages() const OVERRIDE;
    671 #if defined(OS_ANDROID)
    672   virtual void UpdateTopControlsState(TopControlsState constraints,
    673                                       TopControlsState current,
    674                                       bool animate) OVERRIDE;
    675 #endif
    676 
    677   // WebMediaPlayerDelegate implementation -----------------------
    678 
    679   virtual void DidPlay(blink::WebMediaPlayer* player) OVERRIDE;
    680   virtual void DidPause(blink::WebMediaPlayer* player) OVERRIDE;
    681   virtual void PlayerGone(blink::WebMediaPlayer* player) OVERRIDE;
    682 
    683   // Please do not add your stuff randomly to the end here. If there is an
    684   // appropriate section, add it there. If not, there are some random functions
    685   // nearer to the top you can add it to.
    686 
    687   // Cannot use std::set unfortunately since linked_ptr<> does not support
    688   // operator<.
    689   typedef std::vector<linked_ptr<ImageResourceFetcher> >
    690       ImageResourceFetcherList;
    691 
    692  protected:
    693   // RenderWidget overrides:
    694   virtual void Close() OVERRIDE;
    695   virtual void OnResize(const ViewMsg_Resize_Params& params) OVERRIDE;
    696   virtual void DidInitiatePaint() OVERRIDE;
    697   virtual void DidFlushPaint() OVERRIDE;
    698   virtual PepperPluginInstanceImpl* GetBitmapForOptimizedPluginPaint(
    699       const gfx::Rect& paint_bounds,
    700       TransportDIB** dib,
    701       gfx::Rect* location,
    702       gfx::Rect* clip,
    703       float* scale_factor) OVERRIDE;
    704   virtual gfx::Vector2d GetScrollOffset() OVERRIDE;
    705   virtual void DidHandleKeyEvent() OVERRIDE;
    706   virtual bool WillHandleMouseEvent(
    707       const blink::WebMouseEvent& event) OVERRIDE;
    708   virtual bool WillHandleKeyEvent(
    709       const blink::WebKeyboardEvent& event) OVERRIDE;
    710   virtual bool WillHandleGestureEvent(
    711       const blink::WebGestureEvent& event) OVERRIDE;
    712   virtual void DidHandleMouseEvent(const blink::WebMouseEvent& event) OVERRIDE;
    713   virtual void DidHandleTouchEvent(const blink::WebTouchEvent& event) OVERRIDE;
    714   virtual bool HasTouchEventHandlersAt(const gfx::Point& point) const OVERRIDE;
    715   virtual void OnSetFocus(bool enable) OVERRIDE;
    716   virtual void OnWasHidden() OVERRIDE;
    717   virtual void OnWasShown(bool needs_repainting) OVERRIDE;
    718   virtual GURL GetURLForGraphicsContext3D() OVERRIDE;
    719   virtual bool ForceCompositingModeEnabled() OVERRIDE;
    720   virtual void OnImeSetComposition(
    721       const base::string16& text,
    722       const std::vector<blink::WebCompositionUnderline>& underlines,
    723       int selection_start,
    724       int selection_end) OVERRIDE;
    725   virtual void OnImeConfirmComposition(const base::string16& text,
    726                                        const gfx::Range& replacement_range,
    727                                        bool keep_selection) OVERRIDE;
    728   virtual void SetDeviceScaleFactor(float device_scale_factor) OVERRIDE;
    729   virtual ui::TextInputType GetTextInputType() OVERRIDE;
    730   virtual void GetSelectionBounds(gfx::Rect* start, gfx::Rect* end) OVERRIDE;
    731 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
    732   virtual void GetCompositionCharacterBounds(
    733       std::vector<gfx::Rect>* character_bounds) OVERRIDE;
    734   virtual void GetCompositionRange(gfx::Range* range) OVERRIDE;
    735 #endif
    736   virtual bool CanComposeInline() OVERRIDE;
    737   virtual void DidCommitCompositorFrame() OVERRIDE;
    738   virtual void InstrumentWillBeginFrame(int frame_id) OVERRIDE;
    739   virtual void InstrumentDidBeginFrame() OVERRIDE;
    740   virtual void InstrumentDidCancelFrame() OVERRIDE;
    741   virtual void InstrumentWillComposite() OVERRIDE;
    742   virtual bool AllowPartialSwap() const OVERRIDE;
    743 
    744  protected:
    745   explicit RenderViewImpl(RenderViewImplParams* params);
    746 
    747   void Initialize(RenderViewImplParams* params);
    748   virtual void SetScreenMetricsEmulationParameters(
    749       float device_scale_factor,
    750       const gfx::Point& root_layer_offset,
    751       float root_layer_scale) OVERRIDE;
    752 
    753   // Do not delete directly.  This class is reference counted.
    754   virtual ~RenderViewImpl();
    755 
    756  private:
    757   // For unit tests.
    758   friend class ExternalPopupMenuTest;
    759   friend class PepperDeviceTest;
    760   friend class RendererAccessibilityTest;
    761   friend class RenderViewTest;
    762 
    763   // TODO(nasko): Temporarily friend RenderFrameImpl, so we don't duplicate
    764   // utility functions needed in both classes, while we move frame specific
    765   // code away from this class.
    766   friend class RenderFrameImpl;
    767 
    768   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuRemoveTest, RemoveOnChange);
    769   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, NormalCase);
    770   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, ShowPopupThenNavigate);
    771   FRIEND_TEST_ALL_PREFIXES(RendererAccessibilityTest,
    772                            AccessibilityMessagesQueueWhileSwappedOut);
    773   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, DecideNavigationPolicyForWebUI);
    774   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    775                            DidFailProvisionalLoadWithErrorForError);
    776   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    777                            DidFailProvisionalLoadWithErrorForCancellation);
    778   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    779                            DontIgnoreBackAfterNavEntryLimit);
    780   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, ImeComposition);
    781   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, InsertCharacters);
    782   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, JSBlockSentAfterPageLoad);
    783   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, LastCommittedUpdateState);
    784   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnExtendSelectionAndDelete);
    785   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnHandleKeyboardEvent);
    786   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnImeTypeChanged);
    787   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnNavStateChanged);
    788   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnSetTextDirection);
    789   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnUpdateWebPreferences);
    790   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, SendSwapOutACK);
    791   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, ReloadWhileSwappedOut);
    792   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    793                            SetEditableSelectionAndComposition);
    794   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, StaleNavigationsIgnored);
    795   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, UpdateTargetURLWithInvalidURL);
    796   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    797                            GetCompositionCharacterBoundsTest);
    798   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnNavigationHttpPost);
    799   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    800                            DecideNavigationPolicyHandlesAllTopLevel);
    801 #if defined(OS_MACOSX)
    802   FRIEND_TEST_ALL_PREFIXES(RenderViewTest, MacTestCmdUp);
    803 #endif
    804   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, SetHistoryLengthAndPrune);
    805   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, ZoomLimit);
    806   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, NavigateFrame);
    807   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    808                            ShouldUpdateSelectionTextFromContextMenuParams);
    809   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, BasicRenderFrame);
    810   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, TextInputTypeWithPepper);
    811   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
    812                            MessageOrderInDidChangeSelection);
    813   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, SendCandidateWindowEvents);
    814   FRIEND_TEST_ALL_PREFIXES(SuppressErrorPageTest, Suppresses);
    815   FRIEND_TEST_ALL_PREFIXES(SuppressErrorPageTest, DoesNotSuppress);
    816 
    817   typedef std::map<GURL, double> HostZoomLevels;
    818 
    819   enum ErrorPageType {
    820     DNS_ERROR,
    821     HTTP_404,
    822     CONNECTION_ERROR,
    823   };
    824 
    825   static blink::WebReferrerPolicy GetReferrerPolicyFromRequest(
    826       blink::WebFrame* frame,
    827       const blink::WebURLRequest& request);
    828 
    829   static Referrer GetReferrerFromRequest(
    830       blink::WebFrame* frame,
    831       const blink::WebURLRequest& request);
    832 
    833   static webkit_glue::WebURLResponseExtraDataImpl* GetExtraDataFromResponse(
    834       const blink::WebURLResponse& response);
    835 
    836   void UpdateURL(blink::WebFrame* frame);
    837   void UpdateTitle(blink::WebFrame* frame, const base::string16& title,
    838                    blink::WebTextDirection title_direction);
    839   void UpdateSessionHistory(blink::WebFrame* frame);
    840   void SendUpdateState(const blink::WebHistoryItem& item);
    841 
    842   // Update current main frame's encoding and send it to browser window.
    843   // Since we want to let users see the right encoding info from menu
    844   // before finishing loading, we call the UpdateEncoding in
    845   // a) function:DidCommitLoadForFrame. When this function is called,
    846   // that means we have got first data. In here we try to get encoding
    847   // of page if it has been specified in http header.
    848   // b) function:DidReceiveTitle. When this function is called,
    849   // that means we have got specified title. Because in most of webpages,
    850   // title tags will follow meta tags. In here we try to get encoding of
    851   // page if it has been specified in meta tag.
    852   // c) function:DidFinishDocumentLoadForFrame. When this function is
    853   // called, that means we have got whole html page. In here we should
    854   // finally get right encoding of page.
    855   void UpdateEncoding(blink::WebFrame* frame,
    856                       const std::string& encoding_name);
    857 
    858   void OpenURL(blink::WebFrame* frame,
    859                const GURL& url,
    860                const Referrer& referrer,
    861                blink::WebNavigationPolicy policy);
    862 
    863   bool RunJavaScriptMessage(JavaScriptMessageType type,
    864                             const base::string16& message,
    865                             const base::string16& default_value,
    866                             const GURL& frame_url,
    867                             base::string16* result);
    868 
    869   // Sends a message and runs a nested message loop.
    870   bool SendAndRunNestedMessageLoop(IPC::SyncMessage* message);
    871 
    872   // Called when the "pinned to left/right edge" state needs to be updated.
    873   void UpdateScrollState(blink::WebFrame* frame);
    874 
    875   // IPC message handlers ------------------------------------------------------
    876   //
    877   // The documentation for these functions should be in
    878   // content/common/*_messages.h for the message that the function is handling.
    879 
    880   void OnCopy();
    881   void OnCut();
    882   void OnDelete();
    883   void OnExecuteEditCommand(const std::string& name, const std::string& value);
    884   void OnMoveCaret(const gfx::Point& point);
    885   void OnPaste();
    886   void OnPasteAndMatchStyle();
    887   void OnRedo();
    888   void OnReplace(const base::string16& text);
    889   void OnReplaceMisspelling(const base::string16& text);
    890   void OnScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect);
    891   void OnSelectAll();
    892   void OnSelectRange(const gfx::Point& start, const gfx::Point& end);
    893   void OnSetEditCommandsForNextKeyEvent(const EditCommands& edit_commands);
    894   void OnUndo();
    895   void OnUnselect();
    896   void OnAllowBindings(int enabled_bindings_flags);
    897   void OnAllowScriptToClose(bool script_can_close);
    898   void OnCancelDownload(int32 download_id);
    899   void OnClearFocusedNode();
    900   void OnClosePage();
    901   void OnContextMenuClosed(const CustomContextMenuContext& custom_context);
    902   void OnShowContextMenu(const gfx::Point& location);
    903   void OnCopyImageAt(int x, int y);
    904   void OnCSSInsertRequest(const base::string16& frame_xpath,
    905                           const std::string& css);
    906   void OnCustomContextMenuAction(const CustomContextMenuContext& custom_context,
    907       unsigned action);
    908   void OnSetName(const std::string& name);
    909   void OnDeterminePageLanguage();
    910   void OnDisableScrollbarsForSmallWindows(
    911       const gfx::Size& disable_scrollbars_size_limit);
    912   void OnDragSourceEndedOrMoved(const gfx::Point& client_point,
    913                                 const gfx::Point& screen_point,
    914                                 bool ended,
    915                                 blink::WebDragOperation drag_operation);
    916   void OnDragSourceSystemDragEnded();
    917   void OnDragTargetDrop(const gfx::Point& client_pt,
    918                         const gfx::Point& screen_pt,
    919                         int key_modifiers);
    920   void OnDragTargetDragEnter(const DropData& drop_data,
    921                              const gfx::Point& client_pt,
    922                              const gfx::Point& screen_pt,
    923                              blink::WebDragOperationsMask operations_allowed,
    924                              int key_modifiers);
    925   void OnDragTargetDragLeave();
    926   void OnDragTargetDragOver(const gfx::Point& client_pt,
    927                             const gfx::Point& screen_pt,
    928                             blink::WebDragOperationsMask operations_allowed,
    929                             int key_modifiers);
    930   void OnEnablePreferredSizeChangedMode();
    931   void OnEnableAutoResize(const gfx::Size& min_size, const gfx::Size& max_size);
    932   void OnDisableAutoResize(const gfx::Size& new_size);
    933   void OnEnumerateDirectoryResponse(int id,
    934                                     const std::vector<base::FilePath>& paths);
    935   void OnExtendSelectionAndDelete(int before, int after);
    936   void OnFileChooserResponse(
    937       const std::vector<ui::SelectedFileInfo>& files);
    938   void OnFind(int request_id,
    939               const base::string16&,
    940               const blink::WebFindOptions&);
    941   void OnGetAllSavableResourceLinksForCurrentPage(const GURL& page_url);
    942   void OnGetSerializedHtmlDataForCurrentPageWithLocalLinks(
    943       const std::vector<GURL>& links,
    944       const std::vector<base::FilePath>& local_paths,
    945       const base::FilePath& local_directory_name);
    946   void OnMediaPlayerActionAt(const gfx::Point& location,
    947                              const blink::WebMediaPlayerAction& action);
    948   void OnOrientationChangeEvent(int orientation);
    949   void OnPluginActionAt(const gfx::Point& location,
    950                         const blink::WebPluginAction& action);
    951   void OnMoveOrResizeStarted();
    952   void OnNavigate(const ViewMsg_Navigate_Params& params);
    953   void OnPostMessageEvent(const ViewMsg_PostMessage_Params& params);
    954   void OnReleaseDisambiguationPopupDIB(TransportDIB::Handle dib_handle);
    955   void OnReloadFrame();
    956   void OnResetPageEncodingToDefault();
    957   void OnScriptEvalRequest(const base::string16& frame_xpath,
    958                            const base::string16& jscript,
    959                            int id,
    960                            bool notify_result);
    961   void OnSetAccessibilityMode(AccessibilityMode new_mode);
    962   void OnSetActive(bool active);
    963   void OnSetAltErrorPageURL(const GURL& gurl);
    964   void OnSetBackground(const SkBitmap& background);
    965   void OnSetCompositionFromExistingText(
    966       int start, int end,
    967       const std::vector<blink::WebCompositionUnderline>& underlines);
    968   void OnExitFullscreen();
    969   void OnSetEditableSelectionOffsets(int start, int end);
    970   void OnSetHistoryLengthAndPrune(int history_length, int32 minimum_page_id);
    971   void OnSetInitialFocus(bool reverse);
    972   void OnSetPageEncoding(const std::string& encoding_name);
    973   void OnSetRendererPrefs(const RendererPreferences& renderer_prefs);
    974   void OnSetWebUIProperty(const std::string& name, const std::string& value);
    975   void OnSetZoomLevel(double zoom_level);
    976   void OnSetZoomLevelForLoadingURL(const GURL& url, double zoom_level);
    977   void OnShouldClose();
    978   void OnStop();
    979   void OnStopFinding(StopFindAction action);
    980   void OnSuppressDialogsUntilSwapOut();
    981   void OnSwapOut();
    982   void OnThemeChanged();
    983   void OnUpdateTargetURLAck();
    984   void OnUpdateTimezone();
    985   void OnUpdateWebPreferences(const WebPreferences& prefs);
    986   void OnZoom(PageZoom zoom);
    987   void OnZoomFactor(PageZoom zoom, int zoom_center_x, int zoom_center_y);
    988   void OnEnableViewSourceMode();
    989   void OnDisownOpener();
    990   void OnWindowSnapshotCompleted(const int snapshot_id,
    991       const gfx::Size& size, const std::vector<unsigned char>& png);
    992 #if defined(OS_ANDROID)
    993   void OnActivateNearestFindResult(int request_id, float x, float y);
    994   void OnFindMatchRects(int current_version);
    995   void OnSelectPopupMenuItems(bool canceled,
    996                               const std::vector<int>& selected_indices);
    997   void OnUndoScrollFocusedEditableNodeIntoRect();
    998   void OnUpdateTopControlsState(bool enable_hiding,
    999                                 bool enable_showing,
   1000                                 bool animate);
   1001   void OnPauseVideo();
   1002   void OnExtractSmartClipData(const gfx::Rect& rect);
   1003 #elif defined(OS_MACOSX)
   1004   void OnCopyToFindPboard();
   1005   void OnPluginImeCompositionCompleted(const base::string16& text,
   1006                                        int plugin_id);
   1007   void OnSelectPopupMenuItem(int selected_index);
   1008   void OnSetInLiveResize(bool in_live_resize);
   1009   void OnSetWindowVisibility(bool visible);
   1010   void OnWindowFrameChanged(const gfx::Rect& window_frame,
   1011                             const gfx::Rect& view_frame);
   1012 #endif
   1013 
   1014   // Adding a new message handler? Please add it in alphabetical order above
   1015   // and put it in the same position in the .cc file.
   1016 
   1017   // Misc private functions ----------------------------------------------------
   1018   void ZoomFactorHelper(PageZoom zoom, int zoom_center_x, int zoom_center_y,
   1019                         float scaling_increment);
   1020 
   1021   void AltErrorPageFinished(blink::WebFrame* frame,
   1022                             const blink::WebURLRequest& original_request,
   1023                             const blink::WebURLError& original_error,
   1024                             const std::string& html);
   1025 
   1026   // Check whether the preferred size has changed.
   1027   void CheckPreferredSize();
   1028 
   1029   // Initializes |media_stream_client_|, returning true if successful. Returns
   1030   // false if it wasn't possible to create a MediaStreamClient (e.g., WebRTC is
   1031   // disabled) in which case |media_stream_client_| is NULL.
   1032   bool InitializeMediaStreamClient();
   1033 
   1034   // This callback is triggered when DownloadFavicon completes, either
   1035   // succesfully or with a failure. See DownloadFavicon for more
   1036   // details.
   1037   void DidDownloadFavicon(ImageResourceFetcher* fetcher,
   1038                           const SkBitmap& image);
   1039 
   1040   // Requests to download a favicon image. When done, the RenderView is notified
   1041   // by way of DidDownloadFavicon. Returns true if the request was successfully
   1042   // started, false otherwise. id is used to uniquely identify the request and
   1043   // passed back to the DidDownloadFavicon method. If the image has multiple
   1044   // frames, the frame whose size is image_size is returned. If the image
   1045   // doesn't have a frame at the specified size, the first is returned.
   1046   bool DownloadFavicon(int id, const GURL& image_url, int image_size);
   1047 
   1048   GURL GetAlternateErrorPageURL(const GURL& failed_url,
   1049                                 ErrorPageType error_type);
   1050 
   1051   // Locates a sub frame with given xpath
   1052   blink::WebFrame* GetChildFrame(const base::string16& frame_xpath) const;
   1053 
   1054   // Returns the URL being loaded by the given frame's request.
   1055   GURL GetLoadingUrl(blink::WebFrame* frame) const;
   1056 
   1057   // Should only be called if this object wraps a PluginDocument.
   1058   blink::WebPlugin* GetWebPluginFromPluginDocument();
   1059 
   1060   // Returns true if the |params| navigation is to an entry that has been
   1061   // cropped due to a recent navigation the browser did not know about.
   1062   bool IsBackForwardToStaleEntry(const ViewMsg_Navigate_Params& params,
   1063                                  bool is_reload);
   1064 
   1065   bool MaybeLoadAlternateErrorPage(blink::WebFrame* frame,
   1066                                    const blink::WebURLError& error,
   1067                                    bool replace);
   1068 
   1069   // Make this RenderView show an empty, unscriptable page.
   1070   void NavigateToSwappedOutURL(blink::WebFrame* frame);
   1071 
   1072   // If we initiated a navigation, this function will populate |document_state|
   1073   // with the navigation information saved in OnNavigate().
   1074   void PopulateDocumentStateFromPending(DocumentState* document_state);
   1075 
   1076   // Returns a new NavigationState populated with the navigation information
   1077   // saved in OnNavigate().
   1078   NavigationState* CreateNavigationStateFromPending();
   1079 
   1080   // Processes the command-line flags --enable-viewport,
   1081   // --enable-fixed-layout[=w,h] and --enable-pinch.
   1082   void ProcessViewLayoutFlags(const CommandLine& command_line);
   1083 
   1084 #if defined(OS_ANDROID)
   1085   // Launch an Android content intent with the given URL.
   1086   void LaunchAndroidContentIntent(const GURL& intent_url, size_t request_id);
   1087 
   1088   blink::WebMediaPlayer* CreateAndroidWebMediaPlayer(
   1089       blink::WebFrame* frame,
   1090       const blink::WebURL& url,
   1091       blink::WebMediaPlayerClient* client);
   1092 #endif
   1093 
   1094   blink::WebMediaPlayer* CreateWebMediaPlayerForMediaStream(
   1095       blink::WebFrame* frame,
   1096       const blink::WebURL& url,
   1097       blink::WebMediaPlayerClient* client);
   1098 
   1099   // Sends a reply to the current find operation handling if it was a
   1100   // synchronous find request.
   1101   void SendFindReply(int request_id,
   1102                      int match_count,
   1103                      int ordinal,
   1104                      const blink::WebRect& selection_rect,
   1105                      bool final_status_update);
   1106 
   1107   // Returns whether |params.selection_text| should be synchronized to the
   1108   // browser before bringing up the context menu. Static for testing.
   1109   static bool ShouldUpdateSelectionTextFromContextMenuParams(
   1110       const base::string16& selection_text,
   1111       size_t selection_text_offset,
   1112       const gfx::Range& selection_range,
   1113       const ContextMenuParams& params);
   1114 
   1115 
   1116   // Returns the original request url. If there is no redirect, the original
   1117   // url is the same as ds->request()->url(). If the WebDataSource belongs to a
   1118   // frame was loaded by loadData, the original url will be ds->unreachableURL()
   1119   static GURL GetOriginalRequestURL(blink::WebDataSource* ds);
   1120 
   1121   // Starts nav_state_sync_timer_ if it isn't already running.
   1122   void StartNavStateSyncTimerIfNecessary();
   1123 
   1124   // Dispatches the current state of selection on the webpage to the browser if
   1125   // it has changed.
   1126   // TODO(varunjain): delete this method once we figure out how to keep
   1127   // selection handles in sync with the webpage.
   1128   void SyncSelectionIfRequired();
   1129 
   1130 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   1131   void UpdateFontRenderingFromRendererPrefs();
   1132 #else
   1133   void UpdateFontRenderingFromRendererPrefs() {}
   1134 #endif
   1135 
   1136   // Update the target url and tell the browser that the target URL has changed.
   1137   // If |url| is empty, show |fallback_url|.
   1138   void UpdateTargetURL(const GURL& url, const GURL& fallback_url);
   1139 
   1140   // Tells the browser what the new list of favicons for the webpage is.
   1141   void SendUpdateFaviconURL(const std::vector<FaviconURL>& urls);
   1142 
   1143   // Invoked from DidStopLoading(). Sends the current list of loaded favicons to
   1144   // the browser.
   1145   void DidStopLoadingIcons();
   1146 
   1147   // Coordinate conversion -----------------------------------------------------
   1148 
   1149   gfx::RectF ClientRectToPhysicalWindowRect(const gfx::RectF& rect) const;
   1150 
   1151   // Helper for LatencyInfo construction.
   1152   int64 GetLatencyComponentId();
   1153 
   1154   // RenderFrameImpl accessible state ------------------------------------------
   1155   // The following section is the set of methods that RenderFrameImpl needs
   1156   // to access RenderViewImpl state. The set of state variables are page-level
   1157   // specific, so they don't belong in RenderFrameImpl and should remain in
   1158   // this object.
   1159   ObserverList<RenderViewObserver>& observers() {
   1160     return observers_;
   1161   }
   1162 
   1163   // TODO(nasko): Remove this method when we move to frame proxy objects, since
   1164   // the concept of swapped out will be eliminated.
   1165   void set_is_swapped_out(bool swapped_out) {
   1166     is_swapped_out_ = swapped_out;
   1167   }
   1168 
   1169   NavigationGesture navigation_gesture() {
   1170     return navigation_gesture_;
   1171   }
   1172   void set_navigation_gesture(NavigationGesture gesture) {
   1173     navigation_gesture_ = gesture;
   1174   }
   1175 
   1176   // ---------------------------------------------------------------------------
   1177   // ADDING NEW FUNCTIONS? Please keep private functions alphabetized and put
   1178   // it in the same order in the .cc file as it was in the header.
   1179   // ---------------------------------------------------------------------------
   1180 
   1181   // Settings ------------------------------------------------------------------
   1182 
   1183   WebPreferences webkit_preferences_;
   1184   RendererPreferences renderer_preferences_;
   1185 
   1186   HostZoomLevels host_zoom_levels_;
   1187 
   1188   // Whether content state (such as form state, scroll position and page
   1189   // contents) should be sent to the browser immediately. This is normally
   1190   // false, but set to true by some tests.
   1191   bool send_content_state_immediately_;
   1192 
   1193   // Bitwise-ORed set of extra bindings that have been enabled.  See
   1194   // BindingsPolicy for details.
   1195   int enabled_bindings_;
   1196 
   1197   // The alternate error page URL, if one exists.
   1198   GURL alternate_error_page_url_;
   1199 
   1200   // If true, we send IPC messages when |preferred_size_| changes.
   1201   bool send_preferred_size_changes_;
   1202 
   1203   // If non-empty, and |send_preferred_size_changes_| is true, disable drawing
   1204   // scroll bars on windows smaller than this size.  Used for windows that the
   1205   // browser resizes to the size of the content, such as browser action popups.
   1206   // If a render view is set to the minimum size of its content, webkit may add
   1207   // scroll bars.  This makes sense for fixed sized windows, but it does not
   1208   // make sense when the size of the view was chosen to fit the content.
   1209   // This setting ensures that no scroll bars are drawn.  The size limit exists
   1210   // because if the view grows beyond a size known to the browser, scroll bars
   1211   // should be drawn.
   1212   gfx::Size disable_scrollbars_size_limit_;
   1213 
   1214   // Loading state -------------------------------------------------------------
   1215 
   1216   // True if the top level frame is currently being loaded.
   1217   bool is_loading_;
   1218 
   1219   // The gesture that initiated the current navigation.
   1220   NavigationGesture navigation_gesture_;
   1221 
   1222   // Used for popups.
   1223   bool opened_by_user_gesture_;
   1224 
   1225   // Whether this RenderView was created by a frame that was suppressing its
   1226   // opener. If so, we may want to load pages in a separate process.  See
   1227   // decidePolicyForNavigation for details.
   1228   bool opener_suppressed_;
   1229 
   1230   // Whether we must stop creating nested message loops for modal dialogs until
   1231   // OnSwapOut is called.  This is necessary because modal dialogs have a
   1232   // PageGroupLoadDeferrer on the stack that interferes with swapping out.
   1233   bool suppress_dialogs_until_swap_out_;
   1234 
   1235   // Holds state pertaining to a navigation that we initiated.  This is held by
   1236   // the WebDataSource::ExtraData attribute.  We use pending_navigation_state_
   1237   // as a temporary holder for the state until the WebDataSource corresponding
   1238   // to the new navigation is created.  See DidCreateDataSource.
   1239   scoped_ptr<ViewMsg_Navigate_Params> pending_navigation_params_;
   1240 
   1241   // Timer used to delay the updating of nav state (see SyncNavigationState).
   1242   base::OneShotTimer<RenderViewImpl> nav_state_sync_timer_;
   1243 
   1244   // Page IDs ------------------------------------------------------------------
   1245   // See documentation in RenderView.
   1246   int32 page_id_;
   1247 
   1248   // Indicates the ID of the last page that we sent a FrameNavigate to the
   1249   // browser for. This is used to determine if the most recent transition
   1250   // generated a history entry (less than page_id_), or not (equal to or
   1251   // greater than). Note that this will be greater than page_id_ if the user
   1252   // goes back.
   1253   int32 last_page_id_sent_to_browser_;
   1254 
   1255   // The next available page ID to use for this RenderView.  These IDs are
   1256   // specific to a given RenderView and the frames within it.
   1257   int32 next_page_id_;
   1258 
   1259   // The offset of the current item in the history list.
   1260   int history_list_offset_;
   1261 
   1262   // The RenderView's current impression of the history length.  This includes
   1263   // any items that have committed in this process, but because of cross-process
   1264   // navigations, the history may have some entries that were committed in other
   1265   // processes.  We won't know about them until the next navigation in this
   1266   // process.
   1267   int history_list_length_;
   1268 
   1269   // The list of page IDs for each history item this RenderView knows about.
   1270   // Some entries may be -1 if they were rendered by other processes or were
   1271   // restored from a previous session.  This lets us detect attempts to
   1272   // navigate to stale entries that have been cropped from our history.
   1273   std::vector<int32> history_page_ids_;
   1274 
   1275   // Page info -----------------------------------------------------------------
   1276 
   1277   // The last gotten main frame's encoding.
   1278   std::string last_encoding_name_;
   1279 
   1280   // UI state ------------------------------------------------------------------
   1281 
   1282   // The state of our target_url transmissions. When we receive a request to
   1283   // send a URL to the browser, we set this to TARGET_INFLIGHT until an ACK
   1284   // comes back - if a new request comes in before the ACK, we store the new
   1285   // URL in pending_target_url_ and set the status to TARGET_PENDING. If an
   1286   // ACK comes back and we are in TARGET_PENDING, we send the stored URL and
   1287   // revert to TARGET_INFLIGHT.
   1288   //
   1289   // We don't need a queue of URLs to send, as only the latest is useful.
   1290   enum {
   1291     TARGET_NONE,
   1292     TARGET_INFLIGHT,  // We have a request in-flight, waiting for an ACK
   1293     TARGET_PENDING    // INFLIGHT + we have a URL waiting to be sent
   1294   } target_url_status_;
   1295 
   1296   // The URL we show the user in the status bar. We use this to determine if we
   1297   // want to send a new one (we do not need to send duplicates). It will be
   1298   // equal to either |mouse_over_url_| or |focus_url_|, depending on which was
   1299   // updated last.
   1300   GURL target_url_;
   1301 
   1302   // The URL the user's mouse is hovering over.
   1303   GURL mouse_over_url_;
   1304 
   1305   // The URL that has keyboard focus.
   1306   GURL focus_url_;
   1307 
   1308   // The next target URL we want to send to the browser.
   1309   GURL pending_target_url_;
   1310 
   1311   // The text selection the last time DidChangeSelection got called. May contain
   1312   // additional characters before and after the selected text, for IMEs. The
   1313   // portion of this string that is the actual selected text starts at index
   1314   // |selection_range_.GetMin() - selection_text_offset_| and has length
   1315   // |selection_range_.length()|.
   1316   base::string16 selection_text_;
   1317   // The offset corresponding to the start of |selection_text_| in the document.
   1318   size_t selection_text_offset_;
   1319   // Range over the document corresponding to the actual selected text (which
   1320   // could correspond to a substring of |selection_text_|; see above).
   1321   gfx::Range selection_range_;
   1322 
   1323   // External context menu requests we're waiting for. "Internal"
   1324   // (WebKit-originated) context menu events will have an ID of 0 and will not
   1325   // be in this map.
   1326   //
   1327   // We don't want to add internal ones since some of the "special" page
   1328   // handlers in the browser process just ignore the context menu requests so
   1329   // avoid showing context menus, and so this will cause right clicks to leak
   1330   // entries in this map. Most users of the custom context menu (e.g. Pepper
   1331   // plugins) are normally only on "regular" pages and the regular pages will
   1332   // always respond properly to the request, so we don't have to worry so
   1333   // much about leaks.
   1334   IDMap<ContextMenuClient, IDMapExternalPointer> pending_context_menus_;
   1335 
   1336 #if defined(OS_ANDROID)
   1337   // Cache the old top controls state constraints. Used when updating
   1338   // current value only without altering the constraints.
   1339   cc::TopControlsState top_controls_constraints_;
   1340 #endif
   1341 
   1342   // View ----------------------------------------------------------------------
   1343 
   1344   // Cache the preferred size of the page in order to prevent sending the IPC
   1345   // when layout() recomputes but doesn't actually change sizes.
   1346   gfx::Size preferred_size_;
   1347 
   1348   // Used to delay determining the preferred size (to avoid intermediate
   1349   // states for the sizes).
   1350   base::OneShotTimer<RenderViewImpl> check_preferred_size_timer_;
   1351 
   1352   // These store the "is main frame is scrolled all the way to the left
   1353   // or right" state that was last sent to the browser.
   1354   bool cached_is_main_frame_pinned_to_left_;
   1355   bool cached_is_main_frame_pinned_to_right_;
   1356 
   1357   // These store the "has scrollbars" state last sent to the browser.
   1358   bool cached_has_main_frame_horizontal_scrollbar_;
   1359   bool cached_has_main_frame_vertical_scrollbar_;
   1360 
   1361   // Helper objects ------------------------------------------------------------
   1362 
   1363   scoped_ptr<RenderFrameImpl> main_render_frame_;
   1364 
   1365   RendererWebCookieJarImpl cookie_jar_;
   1366 
   1367   // The next group of objects all implement RenderViewObserver, so are deleted
   1368   // along with the RenderView automatically.  This is why we just store
   1369   // weak references.
   1370 
   1371   // Holds a reference to the service which provides desktop notifications.
   1372   NotificationProvider* notification_provider_;
   1373 
   1374   // The geolocation dispatcher attached to this view, lazily initialized.
   1375   GeolocationDispatcher* geolocation_dispatcher_;
   1376 
   1377   // The speech dispatcher attached to this view, lazily initialized.
   1378   InputTagSpeechDispatcher* input_tag_speech_dispatcher_;
   1379 
   1380   // The speech recognition dispatcher attached to this view, lazily
   1381   // initialized.
   1382   SpeechRecognitionDispatcher* speech_recognition_dispatcher_;
   1383 
   1384   // Device orientation dispatcher attached to this view; lazily initialized.
   1385   DeviceOrientationDispatcher* device_orientation_dispatcher_;
   1386 
   1387   // MediaStream dispatcher attached to this view; lazily initialized.
   1388   MediaStreamDispatcher* media_stream_dispatcher_;
   1389 
   1390   // BrowserPluginManager attached to this view; lazily initialized.
   1391   scoped_refptr<BrowserPluginManager> browser_plugin_manager_;
   1392 
   1393   // MediaStreamClient attached to this view; lazily initialized.
   1394   MediaStreamClient* media_stream_client_;
   1395   blink::WebUserMediaClient* web_user_media_client_;
   1396 
   1397   // MIDIClient attached to this view; lazily initialized.
   1398   MIDIDispatcher* midi_dispatcher_;
   1399 
   1400   DevToolsAgent* devtools_agent_;
   1401 
   1402   // The current accessibility mode.
   1403   AccessibilityMode accessibility_mode_;
   1404 
   1405   // Only valid if |accessibility_mode_| is anything other than
   1406   // AccessibilityModeOff.
   1407   RendererAccessibility* renderer_accessibility_;
   1408 
   1409   // Mouse Lock dispatcher attached to this view.
   1410   MouseLockDispatcher* mouse_lock_dispatcher_;
   1411 
   1412 #if defined(OS_ANDROID)
   1413   // Android Specific ---------------------------------------------------------
   1414 
   1415   // The background color of the document body element. This is used as the
   1416   // default background color for filling the screen areas for which we don't
   1417   // have the actual content.
   1418   SkColor body_background_color_;
   1419 
   1420   // Expected id of the next content intent launched. Used to prevent scheduled
   1421   // intents to be launched if aborted.
   1422   size_t expected_content_intent_id_;
   1423 
   1424   // List of click-based content detectors.
   1425   typedef std::vector< linked_ptr<ContentDetector> > ContentDetectorList;
   1426   ContentDetectorList content_detectors_;
   1427 
   1428   // The media player manager for managing all the media players on this view
   1429   // for communicating with the real media player objects in browser process.
   1430   RendererMediaPlayerManager* media_player_manager_;
   1431 
   1432   // A date/time picker object for date and time related input elements.
   1433   scoped_ptr<RendererDateTimePicker> date_time_picker_client_;
   1434 #endif
   1435 
   1436   // Plugins -------------------------------------------------------------------
   1437 
   1438   // All the currently active plugin delegates for this RenderView; kept so
   1439   // that we can enumerate them to send updates about things like window
   1440   // location or tab focus and visibily. These are non-owning references.
   1441   std::set<WebPluginDelegateProxy*> plugin_delegates_;
   1442 
   1443 #if defined(OS_WIN)
   1444   // The ID of the focused NPAPI plug-in.
   1445   int focused_plugin_id_;
   1446 #endif
   1447 
   1448 #if defined(ENABLE_PLUGINS)
   1449   // TODO(jam): these belong on RenderFrame, once the browser knows which frame
   1450   // is focused and sends the IPCs which use these to the correct frame. Until
   1451   // then, we must store these on RenderView as that's the one place that knows
   1452   // about all the RenderFrames for a page.
   1453 
   1454   // Whether or not the focus is on a PPAPI plugin
   1455   PepperPluginInstanceImpl* focused_pepper_plugin_;
   1456 
   1457   // The plugin instance that received the last mouse event. It is set to NULL
   1458   // if the last mouse event went to elements other than Pepper plugins.
   1459   // |pepper_last_mouse_event_target_| is not owned by this class. We depend on
   1460   // the RenderFrameImpl to NULL it out when it destructs.
   1461   PepperPluginInstanceImpl* pepper_last_mouse_event_target_;
   1462 #endif
   1463 
   1464   // Misc ----------------------------------------------------------------------
   1465 
   1466   // The current and pending file chooser completion objects. If the queue is
   1467   // nonempty, the first item represents the currently running file chooser
   1468   // callback, and the remaining elements are the other file chooser completion
   1469   // still waiting to be run (in order).
   1470   struct PendingFileChooser;
   1471   std::deque< linked_ptr<PendingFileChooser> > file_chooser_completions_;
   1472 
   1473   // The current directory enumeration callback
   1474   std::map<int, blink::WebFileChooserCompletion*> enumeration_completions_;
   1475   int enumeration_completion_id_;
   1476 
   1477   // Reports load progress to the browser.
   1478   scoped_ptr<LoadProgressTracker> load_progress_tracker_;
   1479 
   1480   // The SessionStorage namespace that we're assigned to has an ID, and that ID
   1481   // is passed to us upon creation.  WebKit asks for this ID upon first use and
   1482   // uses it whenever asking the browser process to allocate new storage areas.
   1483   int64 session_storage_namespace_id_;
   1484 
   1485   // Stores edit commands associated to the next key event.
   1486   // Shall be cleared as soon as the next key event is processed.
   1487   EditCommands edit_commands_;
   1488 
   1489   // The external popup for the currently showing select popup.
   1490   scoped_ptr<ExternalPopupMenu> external_popup_menu_;
   1491 
   1492   // The node that the context menu was pressed over.
   1493   blink::WebNode context_menu_node_;
   1494 
   1495   // All the registered observers.  We expect this list to be small, so vector
   1496   // is fine.
   1497   ObserverList<RenderViewObserver> observers_;
   1498 
   1499   // Used to inform didChangeSelection() when it is called in the context
   1500   // of handling a InputMsg_SelectRange IPC.
   1501   bool handling_select_range_;
   1502 
   1503   // Wraps the |webwidget_| as a MouseLockDispatcher::LockTarget interface.
   1504   scoped_ptr<MouseLockDispatcher::LockTarget> webwidget_mouse_lock_target_;
   1505 
   1506   // State associated with the GetWindowSnapshot function.
   1507   int next_snapshot_id_;
   1508   typedef std::map<int, WindowSnapshotCallback> PendingSnapshotMap;
   1509   PendingSnapshotMap pending_snapshots_;
   1510 
   1511   // Allows to selectively disable partial buffer swap for this renderer's
   1512   // compositor.
   1513   bool allow_partial_swap_;
   1514 
   1515   // Allows JS to access DOM automation. The JS object is only exposed when the
   1516   // DOM automation bindings are enabled.
   1517   scoped_ptr<DomAutomationController> dom_automation_controller_;
   1518 
   1519   // This field stores drag/drop related info for the event that is currently
   1520   // being handled. If the current event results in starting a drag/drop
   1521   // session, this info is sent to the browser along with other drag/drop info.
   1522   DragEventSourceInfo possible_drag_event_info_;
   1523 
   1524   // NOTE: stats_collection_observer_ should be the last members because their
   1525   // constructors call the AddObservers method of RenderViewImpl.
   1526   scoped_ptr<StatsCollectionObserver> stats_collection_observer_;
   1527 
   1528   ui::MenuSourceType context_menu_source_type_;
   1529   gfx::Point touch_editing_context_menu_location_;
   1530 
   1531   // ---------------------------------------------------------------------------
   1532   // ADDING NEW DATA? Please see if it fits appropriately in one of the above
   1533   // sections rather than throwing it randomly at the end. If you're adding a
   1534   // bunch of stuff, you should probably create a helper class and put your
   1535   // data and methods on that to avoid bloating RenderView more.  You can
   1536   // use the Observer interface to filter IPC messages and receive frame change
   1537   // notifications.
   1538   // ---------------------------------------------------------------------------
   1539 
   1540   DISALLOW_COPY_AND_ASSIGN(RenderViewImpl);
   1541 };
   1542 
   1543 }  // namespace content
   1544 
   1545 #endif  // CONTENT_RENDERER_RENDER_VIEW_IMPL_H_
   1546