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
|
// Copyright (c) 2006-2008 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 CHROME_BROWSER_TAB_CONTENTS_TAB_CONTENTS_VIEW_H_
#define CHROME_BROWSER_TAB_CONTENTS_TAB_CONTENTS_VIEW_H_
#include <map>
#include <string>
#include "base/basictypes.h"
#include "base/gfx/native_widget_types.h"
#include "base/gfx/rect.h"
#include "base/gfx/size.h"
#include "chrome/browser/renderer_host/render_view_host_delegate.h"
#include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
class Browser;
class RenderViewHost;
class RenderWidgetHost;
class RenderWidgetHostView;
class WebContents;
class WebKeyboardEvent;
namespace base {
class WaitableEvent;
}
// The TabContentsView is an interface that is implemented by the platform-
// dependent web contents views. The WebContents uses this interface to talk to
// them. View-related messages will also get forwarded directly to this class
// from RenderViewHost via RenderViewHostDelegate::View.
//
// It contains a small amount of logic with respect to creating new sub-view
// that should be the same for all platforms.
class TabContentsView : public RenderViewHostDelegate::View {
public:
explicit TabContentsView(WebContents* web_contents);
virtual ~TabContentsView() {}
// Creates the appropriate type of TabContentsView for the current system.
// The return value is a new heap allocated view with ownership passing to
// the caller.
static TabContentsView* Create(WebContents* web_contents);
WebContents* web_contents() const { return web_contents_; }
virtual void CreateView() = 0;
// Sets up the View that holds the rendered web page, receives messages for
// it and contains page plugins. The host view should be sized to the current
// size of the WebContents.
virtual RenderWidgetHostView* CreateViewForWidget(
RenderWidgetHost* render_widget_host) = 0;
// Returns the native widget that contains the contents of the tab.
virtual gfx::NativeView GetNativeView() const = 0;
// Returns the native widget with the main content of the tab (i.e. the main
// render view host, though there may be many popups in the tab as children of
// the container).
virtual gfx::NativeView GetContentNativeView() const = 0;
// Returns the outermost native view. This will be used as the parent for
// dialog boxes.
virtual gfx::NativeWindow GetTopLevelNativeWindow() const = 0;
// Computes the rectangle for the native widget that contains the contents of
// the tab relative to its parent.
virtual void GetContainerBounds(gfx::Rect *out) const = 0;
// Helper function for GetContainerBounds. Most callers just want to know the
// size, and this makes it more clear.
gfx::Size GetContainerSize() const {
gfx::Rect rc;
GetContainerBounds(&rc);
return gfx::Size(rc.width(), rc.height());
}
// Called when the WebContents is being destroyed. This should clean up child
// windows that are part of the view.
//
// TODO(brettw) It seems like this might be able to be done internally as the
// window is being torn down without input from the WebContents. Try to
// implement functions that way rather than adding stuff here.
virtual void OnContentsDestroy() = 0;
// Sets the page title for the native widgets corresponding to the view. This
// is not strictly necessary and isn't expected to be displayed anywhere, but
// can aid certain debugging tools such as Spy++ on Windows where you are
// trying to find a specific window.
virtual void SetPageTitle(const std::wstring& title) = 0;
// Schedules a complete repaint of the window. This is used for cases where
// the existing contents became invalid due to an external event, such as the
// renderer crashing.
virtual void Invalidate() = 0;
// TODO(brettw) this is a hack. It's used in two places at the time of this
// writing: (1) when render view hosts switch, we need to size the replaced
// one to be correct, since it wouldn't have known about sizes that happened
// while it was hidden; (2) in constrained windows.
//
// (1) will be fixed once interstitials are cleaned up. (2) seems like it
// should be cleaned up or done some other way, since this works for normal
// TabContents without the special code.
virtual void SizeContents(const gfx::Size& size) = 0;
// Invoked from the platform dependent web contents view when a
// RenderWidgetHost is deleted. Removes |host| from internal maps.
void RenderWidgetHostDestroyed(RenderWidgetHost* host);
// Sets focus to the native widget for this tab.
virtual void Focus() = 0;
// Sets focus to the appropriate element when the tab contents is shown the
// first time.
virtual void SetInitialFocus() = 0;
// Stores the currently focused view.
virtual void StoreFocus() = 0;
// Restores focus to the last focus view. If StoreFocus has not yet been
// invoked, SetInitialFocus is invoked.
virtual void RestoreFocus() = 0;
protected:
TabContentsView() {} // Abstract interface.
// Internal functions used to support the CreateNewWidget() method. If a
// platform requires plugging into widget creation at a lower level then a
// subclass might want to override these functions, but otherwise they should
// be fine just implementing RenderWidgetHostView::InitAsPopup().
//
// The Create function returns the newly created widget so it can be
// associated with the given route. When the widget needs to be shown later,
// we'll look it up again and pass the object to the Show functions rather
// than the route ID.
virtual RenderWidgetHostView* CreateNewWidgetInternal(int route_id,
bool activatable);
virtual void ShowCreatedWidgetInternal(RenderWidgetHostView* widget_host_view,
const gfx::Rect& initial_pos);
// Common implementations of some RenderViewHostDelegate::View methods.
RenderViewHostDelegateViewHelper delegate_view_helper_;
private:
// We implement these functions on RenderViewHostDelegate::View directly and
// do some book-keeping associated with the request. The request is then
// forwarded to *Internal which does platform-specific work.
virtual void CreateNewWindow(int route_id,
base::WaitableEvent* modal_dialog_event);
virtual void CreateNewWidget(int route_id, bool activatable);
virtual void ShowCreatedWindow(int route_id,
WindowOpenDisposition disposition,
const gfx::Rect& initial_pos,
bool user_gesture);
virtual void ShowCreatedWidget(int route_id, const gfx::Rect& initial_pos);
// The WebContents whose contents we display.
WebContents* web_contents_;
// Tracks created WebContents objects that have not been shown yet. They are
// identified by the route ID passed to CreateNewWindow.
typedef std::map<int, WebContents*> PendingContents;
PendingContents pending_contents_;
// These maps hold on to the widgets that we created on behalf of the
// renderer that haven't shown yet.
typedef std::map<int, RenderWidgetHostView*> PendingWidgetViews;
PendingWidgetViews pending_widget_views_;
DISALLOW_COPY_AND_ASSIGN(TabContentsView);
};
#endif // CHROME_BROWSER_TAB_CONTENTS_TAB_CONTENTS_VIEW_H_
|
