OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "extensions/renderer/guest_view/guest_view_container.h" | 5 #include "extensions/renderer/guest_view/guest_view_container.h" |
6 | 6 |
7 #include "content/public/renderer/browser_plugin_delegate.h" | 7 #include "content/public/renderer/browser_plugin_delegate.h" |
8 #include "content/public/renderer/render_frame.h" | 8 #include "content/public/renderer/render_frame.h" |
9 #include "content/public/renderer/render_view.h" | |
9 #include "extensions/common/extension_messages.h" | 10 #include "extensions/common/extension_messages.h" |
10 #include "extensions/common/guest_view/guest_view_constants.h" | 11 #include "extensions/common/guest_view/guest_view_constants.h" |
12 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
13 #include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h" | |
14 #include "third_party/WebKit/public/web/WebView.h" | |
15 | |
16 namespace { | |
17 typedef std::pair<int, int> GuestViewID; | |
18 typedef std::map<GuestViewID, extensions::GuestViewContainer*> | |
19 GuestViewContainerMap; | |
20 static base::LazyInstance<GuestViewContainerMap> g_guest_view_container_map = | |
21 LAZY_INSTANCE_INITIALIZER; | |
22 } // namespace | |
11 | 23 |
12 namespace extensions { | 24 namespace extensions { |
13 | 25 |
14 GuestViewContainer::GuestViewContainer( | 26 GuestViewContainer::GuestViewContainer( |
15 content::RenderFrame* render_frame, | 27 content::RenderFrame* render_frame, |
16 const std::string& mime_type) | 28 const std::string& mime_type) |
17 : content::BrowserPluginDelegate(render_frame, mime_type), | 29 : content::BrowserPluginDelegate(render_frame, mime_type), |
18 content::RenderFrameObserver(render_frame), | 30 content::RenderFrameObserver(render_frame), |
19 mime_type_(mime_type), | 31 mime_type_(mime_type), |
20 element_instance_id_(guestview::kInstanceIDNone) { | 32 element_instance_id_(guestview::kInstanceIDNone), |
33 attached_(false), | |
34 attach_pending_(false), | |
35 isolate_(NULL) { | |
21 } | 36 } |
22 | 37 |
23 GuestViewContainer::~GuestViewContainer() { | 38 GuestViewContainer::~GuestViewContainer() { |
39 if (element_instance_id_ != guestview::kInstanceIDNone) { | |
40 g_guest_view_container_map.Get().erase( | |
41 GuestViewID(render_frame()->GetRenderView()->GetRoutingID(), | |
42 element_instance_id_)); | |
43 } | |
44 } | |
45 | |
46 GuestViewContainer* GuestViewContainer::FromID(int render_view_routing_id, | |
47 int element_instance_id) { | |
48 GuestViewContainerMap* guest_view_containers = | |
49 g_guest_view_container_map.Pointer(); | |
50 GuestViewContainerMap::iterator it = guest_view_containers->find( | |
51 GuestViewID(render_view_routing_id, element_instance_id)); | |
52 return it == guest_view_containers->end() ? NULL : it->second; | |
53 } | |
54 | |
55 | |
56 void GuestViewContainer::AttachGuest(int element_instance_id, | |
57 int guest_instance_id, | |
58 scoped_ptr<base::DictionaryValue> params, | |
59 v8::Handle<v8::Function> callback, | |
60 v8::Isolate* isolate) { | |
61 if (attach_pending_) | |
lazyboy
2014/09/17 18:24:00
What happens if attached_ = true?
Fady Samuel
2014/09/17 20:25:46
Then we reattach. <appview> supports reattachment,
| |
62 return; | |
63 | |
64 // Step 1, send the attach params to chrome/. | |
65 render_frame()->Send(new ExtensionHostMsg_AttachGuest( | |
66 render_frame()->GetRenderView()->GetRoutingID(), | |
67 element_instance_id, | |
68 guest_instance_id, | |
69 *params)); | |
70 | |
71 // Step 2, attach plugin through content/. | |
72 render_frame()->AttachGuest(element_instance_id); | |
73 | |
74 callback_.reset(callback); | |
75 isolate_ = isolate; | |
76 attach_pending_ = true; | |
24 } | 77 } |
25 | 78 |
26 void GuestViewContainer::SetElementInstanceID(int element_instance_id) { | 79 void GuestViewContainer::SetElementInstanceID(int element_instance_id) { |
80 DCHECK_EQ(element_instance_id_, guestview::kInstanceIDNone); | |
27 element_instance_id_ = element_instance_id; | 81 element_instance_id_ = element_instance_id; |
82 g_guest_view_container_map.Get().insert( | |
83 std::make_pair( | |
84 GuestViewID(render_frame()->GetRenderView()->GetRoutingID(), | |
85 element_instance_id), | |
86 this)); | |
28 } | 87 } |
29 | 88 |
30 void GuestViewContainer::DidFinishLoading() { | 89 void GuestViewContainer::DidFinishLoading() { |
31 if (mime_type_.empty()) | 90 if (mime_type_.empty()) |
32 return; | 91 return; |
33 | 92 |
34 DCHECK_NE(element_instance_id_, guestview::kInstanceIDNone); | 93 DCHECK_NE(element_instance_id_, guestview::kInstanceIDNone); |
35 render_frame()->Send(new ExtensionHostMsg_CreateMimeHandlerViewGuest( | 94 render_frame()->Send(new ExtensionHostMsg_CreateMimeHandlerViewGuest( |
36 routing_id(), html_string_, mime_type_, element_instance_id_)); | 95 routing_id(), html_string_, mime_type_, element_instance_id_)); |
37 } | 96 } |
38 | 97 |
39 void GuestViewContainer::DidReceiveData(const char* data, int data_length) { | 98 void GuestViewContainer::DidReceiveData(const char* data, int data_length) { |
40 std::string value(data, data_length); | 99 std::string value(data, data_length); |
41 html_string_ += value; | 100 html_string_ += value; |
42 } | 101 } |
43 | 102 |
44 void GuestViewContainer::OnDestruct() { | 103 void GuestViewContainer::OnDestruct() { |
45 // GuestViewContainer's lifetime is managed by BrowserPlugin so don't let | 104 // GuestViewContainer's lifetime is managed by BrowserPlugin so don't let |
46 // RenderFrameObserver self-destruct here. | 105 // RenderFrameObserver self-destruct here. |
47 } | 106 } |
48 | 107 |
49 bool GuestViewContainer::OnMessageReceived(const IPC::Message& message) { | 108 bool GuestViewContainer::OnMessageReceived(const IPC::Message& message) { |
50 if (message.type() != ExtensionMsg_CreateMimeHandlerViewGuestACK::ID) | 109 if (!ShouldHandleMessage(message)) |
51 return false; | 110 return false; |
52 | 111 |
53 DCHECK_NE(element_instance_id_, guestview::kInstanceIDNone); | 112 DCHECK_NE(element_instance_id_, guestview::kInstanceIDNone); |
54 int element_instance_id = guestview::kInstanceIDNone; | 113 int element_instance_id = guestview::kInstanceIDNone; |
55 PickleIterator iter(message); | 114 PickleIterator iter(message); |
56 bool success = iter.ReadInt(&element_instance_id); | 115 bool success = iter.ReadInt(&element_instance_id); |
57 DCHECK(success); | 116 DCHECK(success); |
58 if (element_instance_id != element_instance_id_) | 117 if (element_instance_id != element_instance_id_) |
59 return false; | 118 return false; |
60 | 119 |
61 bool handled = true; | 120 bool handled = true; |
62 IPC_BEGIN_MESSAGE_MAP(GuestViewContainer, message) | 121 IPC_BEGIN_MESSAGE_MAP(GuestViewContainer, message) |
63 IPC_MESSAGE_HANDLER(ExtensionMsg_CreateMimeHandlerViewGuestACK, | 122 IPC_MESSAGE_HANDLER(ExtensionMsg_CreateMimeHandlerViewGuestACK, |
64 OnCreateMimeHandlerViewGuestACK) | 123 OnCreateMimeHandlerViewGuestACK) |
124 IPC_MESSAGE_HANDLER(ExtensionMsg_GuestAttached, OnGuestAttached) | |
65 IPC_MESSAGE_UNHANDLED(handled = false) | 125 IPC_MESSAGE_UNHANDLED(handled = false) |
66 IPC_END_MESSAGE_MAP() | 126 IPC_END_MESSAGE_MAP() |
67 return handled; | 127 return handled; |
68 } | 128 } |
69 | 129 |
70 void GuestViewContainer::OnCreateMimeHandlerViewGuestACK( | 130 void GuestViewContainer::OnCreateMimeHandlerViewGuestACK( |
71 int element_instance_id) { | 131 int element_instance_id) { |
72 DCHECK_NE(element_instance_id_, guestview::kInstanceIDNone); | 132 DCHECK_NE(element_instance_id_, guestview::kInstanceIDNone); |
73 DCHECK_EQ(element_instance_id_, element_instance_id); | 133 DCHECK_EQ(element_instance_id_, element_instance_id); |
74 DCHECK(!mime_type_.empty()); | 134 DCHECK(!mime_type_.empty()); |
75 render_frame()->AttachGuest(element_instance_id); | 135 render_frame()->AttachGuest(element_instance_id); |
76 } | 136 } |
77 | 137 |
138 void GuestViewContainer::OnGuestAttached(int element_instance_id, | |
139 int guest_routing_id) { | |
140 attached_ = true; | |
141 attach_pending_ = false; | |
142 | |
143 if (callback_.IsEmpty()) | |
144 return; | |
145 | |
146 content::RenderView* render_view = | |
147 content::RenderView::FromRoutingID(guest_routing_id); | |
148 if (!render_view) | |
149 return; | |
150 | |
151 v8::HandleScope handle_scope(isolate_); | |
152 v8::Handle<v8::Function> callback = callback_.NewHandle(isolate_); | |
lazyboy
2014/09/17 18:24:00
Can you ask someone else familiar with this code t
Fady Samuel
2014/09/17 20:25:46
Will do. Please note that this code is modeled aft
| |
153 v8::Handle<v8::Context> context = callback->CreationContext(); | |
154 if (context.IsEmpty()) | |
155 return; | |
156 | |
157 blink::WebFrame* frame = render_view->GetWebView()->mainFrame(); | |
158 v8::Local<v8::Value> window = frame->mainWorldScriptContext()->Global(); | |
159 | |
160 const int argc = 1; | |
161 v8::Handle<v8::Value> argv[argc] = { window }; | |
162 | |
163 v8::Context::Scope context_scope(context); | |
164 blink::WebScopedMicrotaskSuppression suppression; | |
165 | |
166 callback->Call(context->Global(), argc, argv); | |
lazyboy
2014/09/17 18:24:00
reset callback_ here
Fady Samuel
2014/09/17 20:25:46
Done.
| |
167 } | |
168 | |
169 // static | |
170 bool GuestViewContainer::ShouldHandleMessage(const IPC::Message& message) { | |
171 switch (message.type()) { | |
172 case ExtensionMsg_CreateMimeHandlerViewGuestACK::ID: | |
173 case ExtensionMsg_GuestAttached::ID: | |
174 return true; | |
175 default: | |
176 break; | |
177 } | |
178 return false; | |
179 } | |
180 | |
78 } // namespace extensions | 181 } // namespace extensions |
OLD | NEW |