forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathrender_view_impl.h
1568 lines (1347 loc) · 68.3 KB
/
render_view_impl.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_RENDERER_RENDER_VIEW_IMPL_H_
#define CONTENT_RENDERER_RENDER_VIEW_IMPL_H_
#include <set>
#include "base/basictypes.h"
#include "base/gtest_prod_util.h"
#include "base/id_map.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/timer.h"
#include "base/values.h"
#include "build/build_config.h"
#include "content/common/content_export.h"
#include "content/common/drag_event_source_info.h"
#include "content/common/edit_command.h"
#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
#include "content/common/navigation_gesture.h"
#include "content/common/view_message_enums.h"
#include "content/public/common/javascript_message_type.h"
#include "content/public/common/page_zoom.h"
#include "content/public/common/referrer.h"
#include "content/public/common/renderer_preferences.h"
#include "content/public/common/stop_find_action.h"
#include "content/public/renderer/render_view.h"
#include "content/renderer/pepper/pepper_plugin_delegate_impl.h"
#include "content/renderer/render_widget.h"
#include "content/renderer/renderer_webcookiejar_impl.h"
#include "ipc/ipc_platform_file.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrameClient.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebHistoryItem.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebIconURL.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebNavigationType.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebPageSerializerClient.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebPageVisibilityState.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebViewClient.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebFileSystem.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h"
#include "ui/surface/transport_dib.h"
#include "webkit/glue/webpreferences.h"
#include "webkit/media/webmediaplayer_delegate.h"
#include "webkit/plugins/npapi/webplugin_page_delegate.h"
#if defined(OS_ANDROID)
#include "content/renderer/android/content_detector.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebContentDetectionResult.h"
#endif
#if defined(COMPILER_MSVC)
// RenderViewImpl is a diamond-shaped hierarchy, with WebWidgetClient at the
// root. VS warns when we inherit the WebWidgetClient method implementations
// from RenderWidget. It's safe to ignore that warning.
#pragma warning(disable: 4250)
#endif
class CommandLine;
class PepperDeviceTest;
class SkBitmap;
struct PP_NetAddress_Private;
struct ViewMsg_Navigate_Params;
struct ViewMsg_PostMessage_Params;
struct ViewMsg_StopFinding_Params;
struct ViewMsg_SwapOut_Params;
struct WebDropData;
namespace ui {
struct SelectedFileInfo;
} // namespace ui
namespace webkit {
namespace ppapi {
class PluginInstance;
class WebPluginImpl;
} // namespace ppapi
} // namespace webkit
namespace webkit_glue {
class ImageResourceFetcher;
class ResourceFetcher;
}
#if defined(OS_ANDROID)
namespace webkit_media {
class MediaPlayerBridgeManagerImpl;
class WebMediaPlayerManagerAndroid;
}
#endif
namespace WebKit {
class WebApplicationCacheHost;
class WebApplicationCacheHostClient;
class WebCompositorOutputSurface;
class WebDOMMessageEvent;
class WebDataSource;
class WebDragData;
class WebGeolocationClient;
class WebGestureEvent;
class WebIconURL;
class WebImage;
class WebPeerConnection00Handler;
class WebPeerConnection00HandlerClient;
class WebMediaPlayer;
class WebMediaPlayerClient;
class WebMouseEvent;
class WebPeerConnectionHandler;
class WebPeerConnectionHandlerClient;
class WebSocketStreamHandle;
class WebSpeechInputController;
class WebSpeechInputListener;
class WebSpeechRecognizer;
class WebStorageNamespace;
class WebTouchEvent;
class WebURLRequest;
class WebUserMediaClient;
struct WebActiveWheelFlingParameters;
struct WebFileChooserParams;
struct WebFindOptions;
struct WebMediaPlayerAction;
struct WebPluginAction;
struct WebPoint;
struct WebWindowFeatures;
#if defined(OS_ANDROID)
class WebHitTestResult;
#endif
}
namespace content {
class BrowserPluginManager;
class DeviceOrientationDispatcher;
class DevToolsAgent;
class DocumentState;
class DomAutomationController;
class ExternalPopupMenu;
class GeolocationDispatcher;
class InputTagSpeechDispatcher;
class JavaBridgeDispatcher;
class LoadProgressTracker;
class MediaStreamDispatcher;
class MediaStreamImpl;
class MouseLockDispatcher;
class NavigationState;
class NotificationProvider;
class RenderViewObserver;
class RenderViewTest;
class RendererAccessibility;
class RendererPpapiHost;
class RendererWebColorChooserImpl;
class RenderWidgetFullscreenPepper;
class SpeechRecognitionDispatcher;
class WebIntentsHost;
class WebPluginDelegateProxy;
class WebUIBindings;
struct CustomContextMenuContext;
struct FileChooserParams;
struct RenderViewImplParams;
#if defined(OS_ANDROID)
class WebMediaPlayerProxyImplAndroid;
#endif
// We need to prevent a page from trying to create infinite popups. It is not
// as simple as keeping a count of the number of immediate children
// popups. Having an html file that window.open()s itself would create
// an unlimited chain of RenderViews who only have one RenderView child.
//
// Therefore, each new top level RenderView creates a new counter and shares it
// with all its children and grandchildren popup RenderViewImpls created with
// createView() to have a sort of global limit for the page so no more than
// kMaximumNumberOfPopups popups are created.
//
// This is a RefCounted holder of an int because I can't say
// scoped_refptr<int>.
typedef base::RefCountedData<int> SharedRenderViewCounter;
//
// RenderView is an object that manages a WebView object, and provides a
// communication interface with an embedding application process
//
class CONTENT_EXPORT RenderViewImpl
: public RenderWidget,
NON_EXPORTED_BASE(public WebKit::WebViewClient),
NON_EXPORTED_BASE(public WebKit::WebFrameClient),
NON_EXPORTED_BASE(public WebKit::WebPageSerializerClient),
public RenderView,
NON_EXPORTED_BASE(public webkit::npapi::WebPluginPageDelegate),
NON_EXPORTED_BASE(public webkit_media::WebMediaPlayerDelegate),
NON_EXPORTED_BASE(public WebGraphicsContext3DSwapBuffersClient),
public base::SupportsWeakPtr<RenderViewImpl> {
public:
// Creates a new RenderView. If this is a blocked popup or as a new tab,
// opener_id is the routing ID of the RenderView responsible for creating this
// RenderView. |counter| is either a currently initialized counter, or NULL
// (in which case we treat this RenderView as a top level window).
static RenderViewImpl* Create(
int32 opener_id,
const RendererPreferences& renderer_prefs,
const webkit_glue::WebPreferences& webkit_prefs,
SharedRenderViewCounter* counter,
int32 routing_id,
int32 surface_id,
int64 session_storage_namespace_id,
const string16& frame_name,
bool is_renderer_created,
bool swapped_out,
int32 next_page_id,
const WebKit::WebScreenInfo& screen_info,
AccessibilityMode accessibility_mode);
// Used by content_layouttest_support to hook into the creation of
// RenderViewImpls.
static void InstallCreateHook(
RenderViewImpl* (*create_render_view_impl)(RenderViewImplParams*));
// Returns the RenderViewImpl containing the given WebView.
static RenderViewImpl* FromWebView(WebKit::WebView* webview);
// May return NULL when the view is closing.
WebKit::WebView* webview() const;
// WebGraphicsContext3DSwapBuffersClient implementation.
// Called by a GraphicsContext associated with this view when swapbuffers
// is posted, completes or is aborted.
virtual void OnViewContextSwapBuffersPosted() OVERRIDE;
virtual void OnViewContextSwapBuffersComplete() OVERRIDE;
virtual void OnViewContextSwapBuffersAborted() OVERRIDE;
int history_list_offset() const { return history_list_offset_; }
const webkit_glue::WebPreferences& webkit_preferences() const {
return webkit_preferences_;
}
bool enable_do_not_track() const {
return renderer_preferences_.enable_do_not_track;
}
void set_send_content_state_immediately(bool value) {
send_content_state_immediately_ = value;
}
MediaStreamDispatcher* media_stream_dispatcher() {
return media_stream_dispatcher_;
}
MouseLockDispatcher* mouse_lock_dispatcher() {
return mouse_lock_dispatcher_;
}
#if defined(OS_ANDROID)
webkit_media::WebMediaPlayerManagerAndroid* media_player_manager() {
return media_player_manager_.get();
}
#endif
// Lazily initialize this view's BrowserPluginManager and return it.
BrowserPluginManager* browser_plugin_manager();
// Functions to add and remove observers for this object.
void AddObserver(RenderViewObserver* observer);
void RemoveObserver(RenderViewObserver* observer);
// Adds the given file chooser request to the file_chooser_completion_ queue
// (see that var for more) and requests the chooser be displayed if there are
// no other waiting items in the queue.
//
// Returns true if the chooser was successfully scheduled. False means we
// didn't schedule anything.
bool ScheduleFileChooser(const FileChooserParams& params,
WebKit::WebFileChooserCompletion* completion);
void LoadNavigationErrorPage(
WebKit::WebFrame* frame,
const WebKit::WebURLRequest& failed_request,
const WebKit::WebURLError& error,
const std::string& html,
bool replace);
// Plugin-related functions --------------------------------------------------
// (See also WebPluginPageDelegate implementation.)
// Notification that the given plugin has crashed.
void PluginCrashed(const FilePath& plugin_path);
// Creates a fullscreen container for a pepper plugin instance.
RenderWidgetFullscreenPepper* CreatePepperFullscreenContainer(
webkit::ppapi::PluginInstance* plugin);
// Informs the render view that a PPAPI plugin has gained or lost focus.
void PpapiPluginFocusChanged();
// Informs the render view that a PPAPI plugin has changed text input status.
void PpapiPluginTextInputTypeChanged();
void PpapiPluginCaretPositionChanged();
// Cancels current composition.
void PpapiPluginCancelComposition();
// Informs the render view that a PPAPI plugin has changed selection.
void PpapiPluginSelectionChanged();
// Notification that a PPAPI plugin has been created.
void PpapiPluginCreated(RendererPpapiHost* host);
// Retrieves the current caret position if a PPAPI plugin has focus.
bool GetPpapiPluginCaretBounds(gfx::Rect* rect);
// Simulates IME events for testing purpose.
void SimulateImeSetComposition(
const string16& text,
const std::vector<WebKit::WebCompositionUnderline>& underlines,
int selection_start,
int selection_end);
void SimulateImeConfirmComposition(const string16& text,
const ui::Range& replacement_range);
#if defined(OS_MACOSX) || defined(OS_WIN)
// Informs the render view that the given plugin has gained or lost focus.
void PluginFocusChanged(bool focused, int plugin_id);
#endif
#if defined(OS_MACOSX)
// Starts plugin IME.
void StartPluginIme();
// Helper routines for accelerated plugin support. Used by the
// WebPluginDelegateProxy, which has a pointer to the RenderView.
gfx::PluginWindowHandle AllocateFakePluginWindowHandle(bool opaque,
bool root);
void DestroyFakePluginWindowHandle(gfx::PluginWindowHandle window);
void AcceleratedSurfaceSetIOSurface(gfx::PluginWindowHandle window,
int32 width,
int32 height,
uint64 io_surface_identifier);
TransportDIB::Handle AcceleratedSurfaceAllocTransportDIB(size_t size);
void AcceleratedSurfaceFreeTransportDIB(TransportDIB::Id dib_id);
void AcceleratedSurfaceSetTransportDIB(gfx::PluginWindowHandle window,
int32 width,
int32 height,
TransportDIB::Handle transport_dib);
void AcceleratedSurfaceBuffersSwapped(gfx::PluginWindowHandle window,
uint64 surface_id);
#endif
void RegisterPluginDelegate(WebPluginDelegateProxy* delegate);
void UnregisterPluginDelegate(WebPluginDelegateProxy* delegate);
// Helper function to retrieve information about a plugin for a URL and mime
// type. Returns false if no plugin was found.
// |actual_mime_type| is the actual mime type supported by the
// plugin found that match the URL given (one for each item in
// |info|).
bool GetPluginInfo(const GURL& url,
const GURL& page_url,
const std::string& mime_type,
webkit::WebPluginInfo* plugin_info,
std::string* actual_mime_type);
void TransferActiveWheelFlingAnimation(
const WebKit::WebActiveWheelFlingParameters& params);
// Returns true if the focused element is editable text from the perspective
// of IME support (also used for on-screen keyboard). Works correctly inside
// supported PPAPI plug-ins.
bool HasIMETextFocus();
// IPC::Listener implementation ----------------------------------------------
virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
// WebKit::WebWidgetClient implementation ------------------------------------
// Most methods are handled by RenderWidget.
virtual void didFocus();
virtual void didBlur();
virtual void show(WebKit::WebNavigationPolicy policy);
virtual void runModal();
virtual bool enterFullScreen();
virtual void exitFullScreen();
virtual bool requestPointerLock();
virtual void requestPointerUnlock();
virtual bool isPointerLocked();
virtual void didActivateCompositor(int input_handler_identifier);
// WebKit::WebViewClient implementation --------------------------------------
virtual WebKit::WebView* createView(
WebKit::WebFrame* creator,
const WebKit::WebURLRequest& request,
const WebKit::WebWindowFeatures& features,
const WebKit::WebString& frame_name,
WebKit::WebNavigationPolicy policy);
virtual WebKit::WebWidget* createPopupMenu(WebKit::WebPopupType popup_type);
virtual WebKit::WebExternalPopupMenu* createExternalPopupMenu(
const WebKit::WebPopupMenuInfo& popup_menu_info,
WebKit::WebExternalPopupMenuClient* popup_menu_client);
virtual WebKit::WebStorageNamespace* createSessionStorageNamespace(
unsigned quota);
virtual WebKit::WebCompositorOutputSurface* createOutputSurface() OVERRIDE;
virtual void didAddMessageToConsole(
const WebKit::WebConsoleMessage& message,
const WebKit::WebString& source_name,
unsigned source_line);
virtual void printPage(WebKit::WebFrame* frame);
virtual WebKit::WebNotificationPresenter* notificationPresenter();
virtual bool enumerateChosenDirectory(
const WebKit::WebString& path,
WebKit::WebFileChooserCompletion* chooser_completion);
virtual void initializeHelperPluginWebFrame(WebKit::WebHelperPlugin*);
virtual void didStartLoading();
virtual void didStopLoading();
virtual void didChangeLoadProgress(WebKit::WebFrame* frame,
double load_progress);
virtual bool isSmartInsertDeleteEnabled();
virtual bool isSelectTrailingWhitespaceEnabled();
virtual void didChangeSelection(bool is_selection_empty);
virtual void didExecuteCommand(const WebKit::WebString& command_name);
virtual bool handleCurrentKeyboardEvent();
virtual void didHandleGestureEvent(const WebKit::WebGestureEvent& event,
bool event_swallowed) OVERRIDE;
virtual WebKit::WebColorChooser* createColorChooser(
WebKit::WebColorChooserClient*, const WebKit::WebColor& initial_color);
virtual bool runFileChooser(
const WebKit::WebFileChooserParams& params,
WebKit::WebFileChooserCompletion* chooser_completion);
virtual void runModalAlertDialog(WebKit::WebFrame* frame,
const WebKit::WebString& message);
virtual bool runModalConfirmDialog(WebKit::WebFrame* frame,
const WebKit::WebString& message);
virtual bool runModalPromptDialog(WebKit::WebFrame* frame,
const WebKit::WebString& message,
const WebKit::WebString& default_value,
WebKit::WebString* actual_value);
virtual bool runModalBeforeUnloadDialog(WebKit::WebFrame* frame,
const WebKit::WebString& message);
virtual void showContextMenu(WebKit::WebFrame* frame,
const WebKit::WebContextMenuData& data);
virtual void setStatusText(const WebKit::WebString& text);
virtual void setMouseOverURL(const WebKit::WebURL& url);
virtual void setKeyboardFocusURL(const WebKit::WebURL& url);
virtual void startDragging(WebKit::WebFrame* frame,
const WebKit::WebDragData& data,
WebKit::WebDragOperationsMask mask,
const WebKit::WebImage& image,
const WebKit::WebPoint& imageOffset);
virtual bool acceptsLoadDrops();
virtual void focusNext();
virtual void focusPrevious();
virtual void focusedNodeChanged(const WebKit::WebNode& node);
virtual void numberOfWheelEventHandlersChanged(unsigned num_handlers);
virtual void hasTouchEventHandlers(bool has_handlers);
virtual void didUpdateLayout();
#if defined(OS_ANDROID)
virtual bool didTapMultipleTargets(
const WebKit::WebGestureEvent& event,
const WebKit::WebVector<WebKit::WebRect>& target_rects);
#endif
virtual void navigateBackForwardSoon(int offset);
virtual int historyBackListCount();
virtual int historyForwardListCount();
virtual void postAccessibilityNotification(
const WebKit::WebAccessibilityObject& obj,
WebKit::WebAccessibilityNotification notification);
virtual void didUpdateInspectorSetting(const WebKit::WebString& key,
const WebKit::WebString& value);
virtual WebKit::WebGeolocationClient* geolocationClient();
virtual WebKit::WebSpeechInputController* speechInputController(
WebKit::WebSpeechInputListener* listener);
virtual WebKit::WebSpeechRecognizer* speechRecognizer();
virtual WebKit::WebDeviceOrientationClient* deviceOrientationClient();
virtual void zoomLimitsChanged(double minimum_level, double maximum_level);
virtual void zoomLevelChanged();
virtual void registerProtocolHandler(const WebKit::WebString& scheme,
const WebKit::WebString& base_url,
const WebKit::WebString& url,
const WebKit::WebString& title);
virtual WebKit::WebPageVisibilityState visibilityState() const;
virtual WebKit::WebUserMediaClient* userMediaClient();
virtual void draggableRegionsChanged();
#if defined(OS_ANDROID)
virtual void scheduleContentIntent(const WebKit::WebURL& intent);
virtual void cancelScheduledContentIntents();
virtual WebKit::WebContentDetectionResult detectContentAround(
const WebKit::WebHitTestResult& touch_hit);
#endif
// WebKit::WebFrameClient implementation -------------------------------------
virtual WebKit::WebPlugin* createPlugin(
WebKit::WebFrame* frame,
const WebKit::WebPluginParams& params);
virtual WebKit::WebSharedWorker* createSharedWorker(
WebKit::WebFrame* frame, const WebKit::WebURL& url,
const WebKit::WebString& name, unsigned long long documentId);
virtual WebKit::WebMediaPlayer* createMediaPlayer(
WebKit::WebFrame* frame,
const WebKit::WebURL& url,
WebKit::WebMediaPlayerClient* client);
virtual WebKit::WebApplicationCacheHost* createApplicationCacheHost(
WebKit::WebFrame* frame,
WebKit::WebApplicationCacheHostClient* client);
virtual WebKit::WebCookieJar* cookieJar(WebKit::WebFrame* frame);
virtual void didCreateFrame(WebKit::WebFrame* parent,
WebKit::WebFrame* child);
virtual void frameDetached(WebKit::WebFrame* frame);
virtual void willClose(WebKit::WebFrame* frame);
virtual void loadURLExternally(WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request,
WebKit::WebNavigationPolicy policy);
virtual void loadURLExternally(WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request,
WebKit::WebNavigationPolicy policy,
const WebKit::WebString& suggested_name);
virtual WebKit::WebNavigationPolicy decidePolicyForNavigation(
WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request,
WebKit::WebNavigationType type,
const WebKit::WebNode&,
WebKit::WebNavigationPolicy default_policy,
bool is_redirect);
virtual bool canHandleRequest(WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request);
virtual WebKit::WebURLError cannotHandleRequestError(
WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request);
virtual WebKit::WebURLError cancelledError(
WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request);
virtual void unableToImplementPolicyWithError(
WebKit::WebFrame* frame,
const WebKit::WebURLError& error);
virtual void willSendSubmitEvent(WebKit::WebFrame* frame,
const WebKit::WebFormElement& form);
virtual void willSubmitForm(WebKit::WebFrame* frame,
const WebKit::WebFormElement& form);
virtual void willPerformClientRedirect(WebKit::WebFrame* frame,
const WebKit::WebURL& from,
const WebKit::WebURL& to,
double interval,
double fire_time);
virtual void didCancelClientRedirect(WebKit::WebFrame* frame);
virtual void didCompleteClientRedirect(WebKit::WebFrame* frame,
const WebKit::WebURL& from);
virtual void didCreateDataSource(WebKit::WebFrame* frame,
WebKit::WebDataSource* datasource);
virtual void didStartProvisionalLoad(WebKit::WebFrame* frame);
virtual void didReceiveServerRedirectForProvisionalLoad(
WebKit::WebFrame* frame);
virtual void didFailProvisionalLoad(WebKit::WebFrame* frame,
const WebKit::WebURLError& error);
virtual void didReceiveDocumentData(WebKit::WebFrame* frame,
const char* data, size_t length,
bool& prevent_default);
virtual void didCommitProvisionalLoad(WebKit::WebFrame* frame,
bool is_new_navigation);
virtual void didClearWindowObject(WebKit::WebFrame* frame);
virtual void didCreateDocumentElement(WebKit::WebFrame* frame);
virtual void didReceiveTitle(WebKit::WebFrame* frame,
const WebKit::WebString& title,
WebKit::WebTextDirection direction);
virtual void didChangeIcon(WebKit::WebFrame*,
WebKit::WebIconURL::Type) OVERRIDE;
virtual void didFinishDocumentLoad(WebKit::WebFrame* frame);
virtual void didHandleOnloadEvents(WebKit::WebFrame* frame);
virtual void didFailLoad(WebKit::WebFrame* frame,
const WebKit::WebURLError& error);
virtual void didFinishLoad(WebKit::WebFrame* frame);
virtual void didNavigateWithinPage(WebKit::WebFrame* frame,
bool is_new_navigation);
virtual void didUpdateCurrentHistoryItem(WebKit::WebFrame* frame);
virtual void assignIdentifierToRequest(WebKit::WebFrame* frame,
unsigned identifier,
const WebKit::WebURLRequest& request);
virtual void willSendRequest(WebKit::WebFrame* frame,
unsigned identifier,
WebKit::WebURLRequest& request,
const WebKit::WebURLResponse& redirect_response);
virtual void didReceiveResponse(WebKit::WebFrame* frame,
unsigned identifier,
const WebKit::WebURLResponse& response);
virtual void didFinishResourceLoad(WebKit::WebFrame* frame,
unsigned identifier);
virtual void didFailResourceLoad(WebKit::WebFrame* frame,
unsigned identifier,
const WebKit::WebURLError& error);
virtual void didLoadResourceFromMemoryCache(
WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request,
const WebKit::WebURLResponse&);
virtual void didDisplayInsecureContent(WebKit::WebFrame* frame);
virtual void didRunInsecureContent(
WebKit::WebFrame* frame,
const WebKit::WebSecurityOrigin& origin,
const WebKit::WebURL& target);
virtual void didExhaustMemoryAvailableForScript(WebKit::WebFrame* frame);
virtual void didCreateScriptContext(WebKit::WebFrame* frame,
v8::Handle<v8::Context>,
int extension_group,
int world_id);
virtual void willReleaseScriptContext(WebKit::WebFrame* frame,
v8::Handle<v8::Context>,
int world_id);
virtual void didChangeScrollOffset(WebKit::WebFrame* frame);
#if defined(OS_ANDROID)
virtual void didFirstVisuallyNonEmptyLayout(WebKit::WebFrame*) OVERRIDE;
#endif
virtual void didChangeContentsSize(WebKit::WebFrame* frame,
const WebKit::WebSize& size);
virtual void reportFindInPageMatchCount(int request_id,
int count,
bool final_update);
virtual void reportFindInPageSelection(int request_id,
int active_match_ordinal,
const WebKit::WebRect& sel);
virtual void openFileSystem(WebKit::WebFrame* frame,
WebKit::WebFileSystem::Type type,
long long size,
bool create,
WebKit::WebFileSystemCallbacks* callbacks);
virtual void deleteFileSystem(WebKit::WebFrame* frame,
WebKit::WebFileSystem::Type type,
WebKit::WebFileSystemCallbacks* callbacks);
virtual void queryStorageUsageAndQuota(
WebKit::WebFrame* frame,
WebKit::WebStorageQuotaType type,
WebKit::WebStorageQuotaCallbacks* callbacks);
virtual void requestStorageQuota(
WebKit::WebFrame* frame,
WebKit::WebStorageQuotaType type,
unsigned long long requested_size,
WebKit::WebStorageQuotaCallbacks* callbacks);
virtual void registerIntentService(
WebKit::WebFrame* frame,
const WebKit::WebIntentServiceInfo& service);
virtual void dispatchIntent(WebKit::WebFrame* frame,
const WebKit::WebIntentRequest& intentRequest);
virtual void willOpenSocketStream(
WebKit::WebSocketStreamHandle* handle);
virtual void willStartUsingPeerConnectionHandler(WebKit::WebFrame* frame,
WebKit::WebRTCPeerConnectionHandler* handler) OVERRIDE;
virtual bool willCheckAndDispatchMessageEvent(
WebKit::WebFrame* sourceFrame,
WebKit::WebFrame* targetFrame,
WebKit::WebSecurityOrigin targetOrigin,
WebKit::WebDOMMessageEvent event) OVERRIDE;
virtual WebKit::WebString userAgentOverride(
WebKit::WebFrame* frame,
const WebKit::WebURL& url) OVERRIDE;
virtual bool allowWebGL(WebKit::WebFrame* frame, bool default_value) OVERRIDE;
virtual void didLoseWebGLContext(
WebKit::WebFrame* frame,
int arb_robustness_status_code) OVERRIDE;
// WebKit::WebPageSerializerClient implementation ----------------------------
virtual void didSerializeDataForFrame(
const WebKit::WebURL& frame_url,
const WebKit::WebCString& data,
PageSerializationStatus status) OVERRIDE;
// RenderView implementation -------------------------------------------------
virtual bool Send(IPC::Message* message) OVERRIDE;
virtual int GetRoutingID() const OVERRIDE;
virtual int GetPageId() const OVERRIDE;
virtual gfx::Size GetSize() const OVERRIDE;
virtual webkit_glue::WebPreferences& GetWebkitPreferences() OVERRIDE;
virtual WebKit::WebView* GetWebView() OVERRIDE;
virtual WebKit::WebNode GetFocusedNode() const OVERRIDE;
virtual WebKit::WebNode GetContextMenuNode() const OVERRIDE;
virtual bool IsEditableNode(const WebKit::WebNode& node) const OVERRIDE;
virtual WebKit::WebPlugin* CreatePlugin(
WebKit::WebFrame* frame,
const webkit::WebPluginInfo& info,
const WebKit::WebPluginParams& params) OVERRIDE;
virtual void EvaluateScript(const string16& frame_xpath,
const string16& jscript,
int id,
bool notify_result) OVERRIDE;
virtual bool ShouldDisplayScrollbars(int width, int height) const OVERRIDE;
virtual int GetEnabledBindings() const OVERRIDE;
virtual bool GetContentStateImmediately() const OVERRIDE;
virtual float GetFilteredTimePerFrame() const OVERRIDE;
virtual int ShowContextMenu(ContextMenuClient* client,
const ContextMenuParams& params) OVERRIDE;
virtual void CancelContextMenu(int request_id) OVERRIDE;
virtual WebKit::WebPageVisibilityState GetVisibilityState() const OVERRIDE;
virtual void RunModalAlertDialog(WebKit::WebFrame* frame,
const WebKit::WebString& message) OVERRIDE;
virtual void LoadURLExternally(
WebKit::WebFrame* frame,
const WebKit::WebURLRequest& request,
WebKit::WebNavigationPolicy policy) OVERRIDE;
virtual void Repaint(const gfx::Size& size) OVERRIDE;
virtual void SetEditCommandForNextKeyEvent(const std::string& name,
const std::string& value) OVERRIDE;
virtual void ClearEditCommands() OVERRIDE;
// webkit_glue::WebPluginPageDelegate implementation -------------------------
virtual webkit::npapi::WebPluginDelegate* CreatePluginDelegate(
const FilePath& file_path,
const std::string& mime_type) OVERRIDE;
virtual WebKit::WebPlugin* CreatePluginReplacement(
const FilePath& file_path) OVERRIDE;
virtual void CreatedPluginWindow(gfx::PluginWindowHandle handle) OVERRIDE;
virtual void WillDestroyPluginWindow(gfx::PluginWindowHandle handle) OVERRIDE;
virtual void DidMovePlugin(
const webkit::npapi::WebPluginGeometry& move) OVERRIDE;
virtual void DidStartLoadingForPlugin() OVERRIDE;
virtual void DidStopLoadingForPlugin() OVERRIDE;
virtual WebKit::WebCookieJar* GetCookieJar() OVERRIDE;
// webkit_media::WebMediaPlayerDelegate implementation -----------------------
virtual void DidPlay(WebKit::WebMediaPlayer* player) OVERRIDE;
virtual void DidPause(WebKit::WebMediaPlayer* player) OVERRIDE;
virtual void PlayerGone(WebKit::WebMediaPlayer* player) OVERRIDE;
// Please do not add your stuff randomly to the end here. If there is an
// appropriate section, add it there. If not, there are some random functions
// nearer to the top you can add it to.
// Cannot use std::set unfortunately since linked_ptr<> does not support
// operator<.
typedef std::vector<linked_ptr<webkit_glue::ImageResourceFetcher> >
ImageResourceFetcherList;
protected:
// RenderWidget overrides:
virtual void Close() OVERRIDE;
virtual void OnResize(const gfx::Size& new_size,
const gfx::Rect& resizer_rect,
bool is_fullscreen) OVERRIDE;
virtual void WillInitiatePaint() OVERRIDE;
virtual void DidInitiatePaint() OVERRIDE;
virtual void DidFlushPaint() OVERRIDE;
virtual webkit::ppapi::PluginInstance* GetBitmapForOptimizedPluginPaint(
const gfx::Rect& paint_bounds,
TransportDIB** dib,
gfx::Rect* location,
gfx::Rect* clip,
float* scale_factor) OVERRIDE;
virtual gfx::Vector2d GetScrollOffset() OVERRIDE;
virtual void DidHandleKeyEvent() OVERRIDE;
virtual bool WillHandleMouseEvent(
const WebKit::WebMouseEvent& event) OVERRIDE;
virtual bool WillHandleGestureEvent(
const WebKit::WebGestureEvent& event) OVERRIDE;
virtual void DidHandleMouseEvent(const WebKit::WebMouseEvent& event) OVERRIDE;
virtual void DidHandleTouchEvent(const WebKit::WebTouchEvent& event) OVERRIDE;
virtual void OnSetFocus(bool enable) OVERRIDE;
virtual void OnWasHidden() OVERRIDE;
virtual void OnWasShown(bool needs_repainting) OVERRIDE;
virtual bool SupportsAsynchronousSwapBuffers() OVERRIDE;
virtual bool ForceCompositingModeEnabled() OVERRIDE;
virtual void OnImeSetComposition(
const string16& text,
const std::vector<WebKit::WebCompositionUnderline>& underlines,
int selection_start,
int selection_end) OVERRIDE;
virtual void OnImeConfirmComposition(
const string16& text, const ui::Range& replacement_range) OVERRIDE;
virtual void SetDeviceScaleFactor(float device_scale_factor) OVERRIDE;
virtual ui::TextInputType GetTextInputType() OVERRIDE;
virtual void GetSelectionBounds(gfx::Rect* start, gfx::Rect* end) OVERRIDE;
virtual void GetCompositionCharacterBounds(
std::vector<gfx::Rect>* character_bounds) OVERRIDE;
virtual bool CanComposeInline() OVERRIDE;
virtual bool WebWidgetHandlesCompositorScheduling() const OVERRIDE;
protected:
RenderViewImpl(RenderViewImplParams* params);
// Do not delete directly. This class is reference counted.
virtual ~RenderViewImpl();
private:
// For unit tests.
friend class ExternalPopupMenuTest;
friend class PepperDeviceTest;
friend class RendererAccessibilityTest;
friend class WebIntentsHostTest;
friend class RenderViewTest;
FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuRemoveTest, RemoveOnChange);
FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, NormalCase);
FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, ShowPopupThenNavigate);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, DecideNavigationPolicyForWebUI);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
DontIgnoreBackAfterNavEntryLimit);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, ImeComposition);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, InsertCharacters);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, JSBlockSentAfterPageLoad);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, LastCommittedUpdateState);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnExtendSelectionAndDelete);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnHandleKeyboardEvent);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnImeStateChanged);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnNavStateChanged);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnReplaceAll);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnSetTextDirection);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnUpdateWebPreferences);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, SendSwapOutACK);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
SetEditableSelectionAndComposition);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, StaleNavigationsIgnored);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, UpdateTargetURLWithInvalidURL);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
GetCompositionCharacterBoundsTest);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, OnNavigationHttpPost);
#if defined(OS_MACOSX)
FRIEND_TEST_ALL_PREFIXES(RenderViewTest, MacTestCmdUp);
#endif
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, SetHistoryLengthAndPrune);
FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, ZoomLimit);
typedef std::map<GURL, double> HostZoomLevels;
enum ErrorPageType {
DNS_ERROR,
HTTP_404,
CONNECTION_ERROR,
};
void UpdateURL(WebKit::WebFrame* frame);
void UpdateTitle(WebKit::WebFrame* frame, const string16& title,
WebKit::WebTextDirection title_direction);
void UpdateSessionHistory(WebKit::WebFrame* frame);
void SendUpdateState(const WebKit::WebHistoryItem& item);
// Update current main frame's encoding and send it to browser window.
// Since we want to let users see the right encoding info from menu
// before finishing loading, we call the UpdateEncoding in
// a) function:DidCommitLoadForFrame. When this function is called,
// that means we have got first data. In here we try to get encoding
// of page if it has been specified in http header.
// b) function:DidReceiveTitle. When this function is called,
// that means we have got specified title. Because in most of webpages,
// title tags will follow meta tags. In here we try to get encoding of
// page if it has been specified in meta tag.
// c) function:DidFinishDocumentLoadForFrame. When this function is
// called, that means we have got whole html page. In here we should
// finally get right encoding of page.
void UpdateEncoding(WebKit::WebFrame* frame,
const std::string& encoding_name);
void OpenURL(WebKit::WebFrame* frame,
const GURL& url,
const Referrer& referrer,
WebKit::WebNavigationPolicy policy);
bool RunJavaScriptMessage(JavaScriptMessageType type,
const string16& message,
const string16& default_value,
const GURL& frame_url,
string16* result);
// Sends a message and runs a nested message loop.
bool SendAndRunNestedMessageLoop(IPC::SyncMessage* message);
// Called when the "pinned to left/right edge" state needs to be updated.
void UpdateScrollState(WebKit::WebFrame* frame);
// IPC message handlers ------------------------------------------------------
//
// The documentation for these functions should be in
// render_messages_internal.h for the message that the function is handling.
void OnAllowBindings(int enabled_bindings_flags);
void OnAllowScriptToClose(bool script_can_close);
void OnAsyncFileOpened(base::PlatformFileError error_code,
IPC::PlatformFileForTransit file_for_transit,
int message_id);
void OnPpapiBrokerChannelCreated(int request_id,
const IPC::ChannelHandle& handle);
void OnPpapiBrokerPermissionResult(int request_id, bool result);
void OnCancelDownload(int32 download_id);
void OnClearFocusedNode();
void OnClosePage();
void OnContextMenuClosed(const CustomContextMenuContext& custom_context);
void OnCopy();
void OnCopyImageAt(int x, int y);
void OnCut();
void OnCSSInsertRequest(const string16& frame_xpath,
const std::string& css);
void OnCustomContextMenuAction(const CustomContextMenuContext& custom_context,
unsigned action);
void OnDelete();
void OnDeterminePageLanguage();
void OnDisableScrollbarsForSmallWindows(
const gfx::Size& disable_scrollbars_size_limit);
void OnDisassociateFromPopupCount();
void OnDragSourceEndedOrMoved(const gfx::Point& client_point,
const gfx::Point& screen_point,
bool ended,
WebKit::WebDragOperation drag_operation);
void OnDragSourceSystemDragEnded();
void OnDragTargetDrop(const gfx::Point& client_pt,
const gfx::Point& screen_pt,
int key_modifiers);
void OnDragTargetDragEnter(const WebDropData& drop_data,
const gfx::Point& client_pt,
const gfx::Point& screen_pt,
WebKit::WebDragOperationsMask operations_allowed,
int key_modifiers);
void OnDragTargetDragLeave();
void OnDragTargetDragOver(const gfx::Point& client_pt,
const gfx::Point& screen_pt,
WebKit::WebDragOperationsMask operations_allowed,
int key_modifiers);
void OnEnablePreferredSizeChangedMode();
void OnEnableAutoResize(const gfx::Size& min_size, const gfx::Size& max_size);
void OnDisableAutoResize(const gfx::Size& new_size);
void OnEnumerateDirectoryResponse(int id, const std::vector<FilePath>& paths);
void OnExecuteEditCommand(const std::string& name, const std::string& value);
void OnExtendSelectionAndDelete(int before, int after);
void OnFileChooserResponse(
const std::vector<ui::SelectedFileInfo>& files);
void OnFind(int request_id, const string16&, const WebKit::WebFindOptions&);
void OnGetAllSavableResourceLinksForCurrentPage(const GURL& page_url);
void OnGetSerializedHtmlDataForCurrentPageWithLocalLinks(
const std::vector<GURL>& links,
const std::vector<FilePath>& local_paths,
const FilePath& local_directory_name);
void OnMediaPlayerActionAt(const gfx::Point& location,
const WebKit::WebMediaPlayerAction& action);
// Screen has rotated. 0 = default (portrait), 90 = one turn right, and so on.
void OnOrientationChangeEvent(int orientation);
void OnPluginActionAt(const gfx::Point& location,
const WebKit::WebPluginAction& action);
void OnMoveOrResizeStarted();
void OnNavigate(const ViewMsg_Navigate_Params& params);
void OnPaste();
void OnPasteAndMatchStyle();
void OnPostMessageEvent(const ViewMsg_PostMessage_Params& params);
void OnRedo();
void OnReleaseDisambiguationPopupDIB(TransportDIB::Handle dib_handle);
void OnReloadFrame();
void OnReplace(const string16& text);
void OnReplaceAll(const string16& text);
void OnResetPageEncodingToDefault();
void OnScriptEvalRequest(const string16& frame_xpath,
const string16& jscript,
int id,
bool notify_result);
void OnSelectAll();
void OnSelectRange(const gfx::Point& start, const gfx::Point& end);
void OnSetAccessibilityMode(AccessibilityMode new_mode);
void OnSetActive(bool active);
void OnSetAltErrorPageURL(const GURL& gurl);
void OnSetBackground(const SkBitmap& background);
void OnSetCompositionFromExistingText(
int start, int end,
const std::vector<WebKit::WebCompositionUnderline>& underlines);
void OnSetEditableSelectionOffsets(int start, int end);
void OnSetNavigationStartTime(
const base::TimeTicks& browser_navigation_start);
void OnSetWebUIProperty(const std::string& name, const std::string& value);
void OnSetEditCommandsForNextKeyEvent(
const EditCommands& edit_commands);
void OnSetHistoryLengthAndPrune(int history_length, int32 minimum_page_id);
void OnSetInitialFocus(bool reverse);
void OnScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect);
void OnSetPageEncoding(const std::string& encoding_name);
void OnSetRendererPrefs(const RendererPreferences& renderer_prefs);
void OnSetZoomLevel(double zoom_level);
void OnSetZoomLevelForLoadingURL(const GURL& url, double zoom_level);
void OnExitFullscreen();
void OnShouldClose();
void OnStop();
void OnStopFinding(StopFindAction action);
void OnSwapOut(const ViewMsg_SwapOut_Params& params);
void OnThemeChanged();
void OnUndo();
void OnUpdateTargetURLAck();
void OnUpdateTimezone();
void OnUpdateWebPreferences(const webkit_glue::WebPreferences& prefs);
void OnUnselect();
void OnZoom(PageZoom zoom);
void OnZoomFactor(PageZoom zoom, int zoom_center_x, int zoom_center_y);
void OnEnableViewSourceMode();
void OnJavaBridgeInit();