| // Copyright 2014 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. |
| |
| #include "extensions/browser/guest_view/guest_view_base.h" |
| |
| #include "base/lazy_instance.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "content/public/browser/render_frame_host.h" |
| #include "content/public/browser/render_process_host.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/url_constants.h" |
| #include "extensions/browser/api/extensions_api_client.h" |
| #include "extensions/browser/event_router.h" |
| #include "extensions/browser/extension_registry.h" |
| #include "extensions/browser/guest_view/guest_view_constants.h" |
| #include "extensions/browser/guest_view/guest_view_manager.h" |
| #include "extensions/browser/process_map.h" |
| #include "extensions/common/features/feature.h" |
| #include "extensions/common/features/feature_provider.h" |
| #include "third_party/WebKit/public/web/WebInputEvent.h" |
| |
| using content::WebContents; |
| |
| namespace extensions { |
| |
| namespace { |
| |
| typedef std::map<std::string, GuestViewBase::GuestCreationCallback> |
| GuestViewCreationMap; |
| static base::LazyInstance<GuestViewCreationMap> guest_view_registry = |
| LAZY_INSTANCE_INITIALIZER; |
| |
| typedef std::map<WebContents*, GuestViewBase*> WebContentsGuestViewMap; |
| static base::LazyInstance<WebContentsGuestViewMap> webcontents_guestview_map = |
| LAZY_INSTANCE_INITIALIZER; |
| |
| } // namespace |
| |
| GuestViewBase::Event::Event(const std::string& name, |
| scoped_ptr<base::DictionaryValue> args) |
| : name_(name), args_(args.Pass()) { |
| } |
| |
| GuestViewBase::Event::~Event() { |
| } |
| |
| scoped_ptr<base::DictionaryValue> GuestViewBase::Event::GetArguments() { |
| return args_.Pass(); |
| } |
| |
| // This observer ensures that the GuestViewBase destroys itself when its |
| // embedder goes away. |
| class GuestViewBase::EmbedderWebContentsObserver : public WebContentsObserver { |
| public: |
| explicit EmbedderWebContentsObserver(GuestViewBase* guest) |
| : WebContentsObserver(guest->embedder_web_contents()), |
| destroyed_(false), |
| guest_(guest) { |
| } |
| |
| virtual ~EmbedderWebContentsObserver() { |
| } |
| |
| // WebContentsObserver implementation. |
| virtual void WebContentsDestroyed() OVERRIDE { |
| Destroy(); |
| } |
| |
| virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE { |
| Destroy(); |
| } |
| |
| private: |
| bool destroyed_; |
| GuestViewBase* guest_; |
| |
| void Destroy() { |
| if (destroyed_) |
| return; |
| destroyed_ = true; |
| guest_->embedder_web_contents_ = NULL; |
| guest_->EmbedderDestroyed(); |
| guest_->Destroy(); |
| } |
| |
| DISALLOW_COPY_AND_ASSIGN(EmbedderWebContentsObserver); |
| }; |
| |
| GuestViewBase::GuestViewBase(content::BrowserContext* browser_context, |
| int guest_instance_id) |
| : embedder_web_contents_(NULL), |
| embedder_render_process_id_(0), |
| browser_context_(browser_context), |
| guest_instance_id_(guest_instance_id), |
| view_instance_id_(guestview::kInstanceIDNone), |
| initialized_(false), |
| auto_size_enabled_(false), |
| weak_ptr_factory_(this) { |
| } |
| |
| void GuestViewBase::Init(const std::string& embedder_extension_id, |
| content::WebContents* embedder_web_contents, |
| const base::DictionaryValue& create_params, |
| const WebContentsCreatedCallback& callback) { |
| if (initialized_) |
| return; |
| initialized_ = true; |
| |
| Feature* feature = FeatureProvider::GetAPIFeatures()->GetFeature( |
| GetAPINamespace()); |
| CHECK(feature); |
| |
| ProcessMap* process_map = ProcessMap::Get(browser_context()); |
| CHECK(process_map); |
| |
| const Extension* embedder_extension = ExtensionRegistry::Get(browser_context_) |
| ->enabled_extensions() |
| .GetByID(embedder_extension_id); |
| // Ok for |embedder_extension| to be NULL, the embedder might be WebUI. |
| |
| CHECK(embedder_web_contents); |
| int embedder_process_id = |
| embedder_web_contents->GetRenderProcessHost()->GetID(); |
| |
| Feature::Availability availability = feature->IsAvailableToContext( |
| embedder_extension, |
| process_map->GetMostLikelyContextType(embedder_extension, |
| embedder_process_id), |
| embedder_web_contents->GetLastCommittedURL()); |
| if (!availability.is_available()) { |
| callback.Run(NULL); |
| return; |
| } |
| |
| CreateWebContents(embedder_extension_id, |
| embedder_process_id, |
| create_params, |
| base::Bind(&GuestViewBase::CompleteInit, |
| AsWeakPtr(), |
| embedder_extension_id, |
| embedder_process_id, |
| callback)); |
| } |
| |
| void GuestViewBase::InitWithWebContents( |
| const std::string& embedder_extension_id, |
| int embedder_render_process_id, |
| content::WebContents* guest_web_contents) { |
| DCHECK(guest_web_contents); |
| content::RenderProcessHost* embedder_render_process_host = |
| content::RenderProcessHost::FromID(embedder_render_process_id); |
| |
| embedder_extension_id_ = embedder_extension_id; |
| embedder_render_process_id_ = embedder_render_process_host->GetID(); |
| embedder_render_process_host->AddObserver(this); |
| |
| WebContentsObserver::Observe(guest_web_contents); |
| guest_web_contents->SetDelegate(this); |
| webcontents_guestview_map.Get().insert( |
| std::make_pair(guest_web_contents, this)); |
| GuestViewManager::FromBrowserContext(browser_context_)-> |
| AddGuest(guest_instance_id_, guest_web_contents); |
| |
| // Give the derived class an opportunity to perform additional initialization. |
| DidInitialize(); |
| } |
| |
| void GuestViewBase::SetAutoSize(bool enabled, |
| const gfx::Size& min_size, |
| const gfx::Size& max_size) { |
| min_auto_size_ = min_size; |
| min_auto_size_.SetToMin(max_size); |
| max_auto_size_ = max_size; |
| max_auto_size_.SetToMax(min_size); |
| |
| enabled &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty() && |
| IsAutoSizeSupported(); |
| if (!enabled && !auto_size_enabled_) |
| return; |
| |
| auto_size_enabled_ = enabled; |
| |
| if (!attached()) |
| return; |
| |
| content::RenderViewHost* rvh = guest_web_contents()->GetRenderViewHost(); |
| if (auto_size_enabled_) { |
| rvh->EnableAutoResize(min_auto_size_, max_auto_size_); |
| } else { |
| rvh->DisableAutoResize(element_size_); |
| guest_size_ = element_size_; |
| GuestSizeChangedDueToAutoSize(guest_size_, element_size_); |
| } |
| } |
| |
| // static |
| void GuestViewBase::RegisterGuestViewType( |
| const std::string& view_type, |
| const GuestCreationCallback& callback) { |
| GuestViewCreationMap::iterator it = |
| guest_view_registry.Get().find(view_type); |
| DCHECK(it == guest_view_registry.Get().end()); |
| guest_view_registry.Get()[view_type] = callback; |
| } |
| |
| // static |
| GuestViewBase* GuestViewBase::Create( |
| content::BrowserContext* browser_context, |
| int guest_instance_id, |
| const std::string& view_type) { |
| if (guest_view_registry.Get().empty()) |
| RegisterGuestViewTypes(); |
| |
| GuestViewCreationMap::iterator it = |
| guest_view_registry.Get().find(view_type); |
| if (it == guest_view_registry.Get().end()) { |
| NOTREACHED(); |
| return NULL; |
| } |
| return it->second.Run(browser_context, guest_instance_id); |
| } |
| |
| // static |
| GuestViewBase* GuestViewBase::FromWebContents(WebContents* web_contents) { |
| WebContentsGuestViewMap* guest_map = webcontents_guestview_map.Pointer(); |
| WebContentsGuestViewMap::iterator it = guest_map->find(web_contents); |
| return it == guest_map->end() ? NULL : it->second; |
| } |
| |
| // static |
| GuestViewBase* GuestViewBase::From(int embedder_process_id, |
| int guest_instance_id) { |
| content::RenderProcessHost* host = |
| content::RenderProcessHost::FromID(embedder_process_id); |
| if (!host) |
| return NULL; |
| |
| content::WebContents* guest_web_contents = |
| GuestViewManager::FromBrowserContext(host->GetBrowserContext())-> |
| GetGuestByInstanceIDSafely(guest_instance_id, embedder_process_id); |
| if (!guest_web_contents) |
| return NULL; |
| |
| return GuestViewBase::FromWebContents(guest_web_contents); |
| } |
| |
| // static |
| bool GuestViewBase::IsGuest(WebContents* web_contents) { |
| return !!GuestViewBase::FromWebContents(web_contents); |
| } |
| |
| base::WeakPtr<GuestViewBase> GuestViewBase::AsWeakPtr() { |
| return weak_ptr_factory_.GetWeakPtr(); |
| } |
| |
| bool GuestViewBase::IsAutoSizeSupported() const { |
| return false; |
| } |
| |
| bool GuestViewBase::IsDragAndDropEnabled() const { |
| return false; |
| } |
| |
| void GuestViewBase::RenderProcessExited(content::RenderProcessHost* host, |
| base::ProcessHandle handle, |
| base::TerminationStatus status, |
| int exit_code) { |
| // GuestViewBase tracks the lifetime of its embedder render process until it |
| // is attached to a particular embedder WebContents. At that point, its |
| // lifetime is restricted in scope to the lifetime of its embedder |
| // WebContents. |
| CHECK(!attached()); |
| CHECK_EQ(host->GetID(), embedder_render_process_id()); |
| |
| // This code path may be reached if the embedder WebContents is killed for |
| // whatever reason immediately after a called to GuestViewInternal.createGuest |
| // and before attaching the new guest to a frame. |
| Destroy(); |
| } |
| |
| void GuestViewBase::Destroy() { |
| DCHECK(guest_web_contents()); |
| content::RenderProcessHost* host = |
| content::RenderProcessHost::FromID(embedder_render_process_id()); |
| if (host) |
| host->RemoveObserver(this); |
| WillDestroy(); |
| if (!destruction_callback_.is_null()) |
| destruction_callback_.Run(); |
| |
| webcontents_guestview_map.Get().erase(guest_web_contents()); |
| GuestViewManager::FromBrowserContext(browser_context_)-> |
| RemoveGuest(guest_instance_id_); |
| pending_events_.clear(); |
| |
| delete guest_web_contents(); |
| } |
| |
| void GuestViewBase::DidAttach() { |
| // Give the derived class an opportunity to perform some actions. |
| DidAttachToEmbedder(); |
| |
| SendQueuedEvents(); |
| } |
| |
| void GuestViewBase::ElementSizeChanged(const gfx::Size& old_size, |
| const gfx::Size& new_size) { |
| element_size_ = new_size; |
| } |
| |
| int GuestViewBase::GetGuestInstanceID() const { |
| return guest_instance_id_; |
| } |
| |
| void GuestViewBase::GuestSizeChanged(const gfx::Size& old_size, |
| const gfx::Size& new_size) { |
| if (!auto_size_enabled_) |
| return; |
| guest_size_ = new_size; |
| GuestSizeChangedDueToAutoSize(old_size, new_size); |
| } |
| |
| void GuestViewBase::SetOpener(GuestViewBase* guest) { |
| if (guest && guest->IsViewType(GetViewType())) { |
| opener_ = guest->AsWeakPtr(); |
| return; |
| } |
| opener_ = base::WeakPtr<GuestViewBase>(); |
| } |
| |
| void GuestViewBase::RegisterDestructionCallback( |
| const DestructionCallback& callback) { |
| destruction_callback_ = callback; |
| } |
| |
| void GuestViewBase::WillAttach(content::WebContents* embedder_web_contents, |
| const base::DictionaryValue& extra_params) { |
| // After attachment, this GuestViewBase's lifetime is restricted to the |
| // lifetime of its embedder WebContents. Observing the RenderProcessHost |
| // of the embedder is no longer necessary. |
| embedder_web_contents->GetRenderProcessHost()->RemoveObserver(this); |
| embedder_web_contents_ = embedder_web_contents; |
| embedder_web_contents_observer_.reset( |
| new EmbedderWebContentsObserver(this)); |
| extra_params.GetInteger(guestview::kParameterInstanceId, &view_instance_id_); |
| extra_params_.reset(extra_params.DeepCopy()); |
| |
| WillAttachToEmbedder(); |
| } |
| |
| void GuestViewBase::DidStopLoading(content::RenderViewHost* render_view_host) { |
| if (!IsDragAndDropEnabled()) { |
| const char script[] = "window.addEventListener('dragstart', function() { " |
| " window.event.preventDefault(); " |
| "});"; |
| render_view_host->GetMainFrame()->ExecuteJavaScript( |
| base::ASCIIToUTF16(script)); |
| } |
| DidStopLoading(); |
| } |
| |
| void GuestViewBase::RenderViewReady() { |
| GuestReady(); |
| content::RenderViewHost* rvh = guest_web_contents()->GetRenderViewHost(); |
| if (auto_size_enabled_) { |
| rvh->EnableAutoResize(min_auto_size_, max_auto_size_); |
| } else { |
| rvh->DisableAutoResize(element_size_); |
| } |
| } |
| |
| void GuestViewBase::WebContentsDestroyed() { |
| GuestDestroyed(); |
| delete this; |
| } |
| |
| bool GuestViewBase::ShouldFocusPageAfterCrash() { |
| // Focus is managed elsewhere. |
| return false; |
| } |
| |
| bool GuestViewBase::PreHandleGestureEvent(content::WebContents* source, |
| const blink::WebGestureEvent& event) { |
| return event.type == blink::WebGestureEvent::GesturePinchBegin || |
| event.type == blink::WebGestureEvent::GesturePinchUpdate || |
| event.type == blink::WebGestureEvent::GesturePinchEnd; |
| } |
| |
| GuestViewBase::~GuestViewBase() { |
| } |
| |
| void GuestViewBase::DispatchEventToEmbedder(Event* event) { |
| scoped_ptr<Event> event_ptr(event); |
| |
| if (!attached()) { |
| pending_events_.push_back(linked_ptr<Event>(event_ptr.release())); |
| return; |
| } |
| |
| EventFilteringInfo info; |
| info.SetInstanceID(view_instance_id_); |
| scoped_ptr<base::ListValue> args(new base::ListValue()); |
| args->Append(event->GetArguments().release()); |
| |
| EventRouter::DispatchEvent( |
| embedder_web_contents_, |
| browser_context_, |
| embedder_extension_id_, |
| event->name(), |
| args.Pass(), |
| EventRouter::USER_GESTURE_UNKNOWN, |
| info); |
| } |
| |
| void GuestViewBase::SendQueuedEvents() { |
| if (!attached()) |
| return; |
| while (!pending_events_.empty()) { |
| linked_ptr<Event> event_ptr = pending_events_.front(); |
| pending_events_.pop_front(); |
| DispatchEventToEmbedder(event_ptr.release()); |
| } |
| } |
| |
| void GuestViewBase::CompleteInit(const std::string& embedder_extension_id, |
| int embedder_render_process_id, |
| const WebContentsCreatedCallback& callback, |
| content::WebContents* guest_web_contents) { |
| if (!guest_web_contents) { |
| // The derived class did not create a WebContents so this class serves no |
| // purpose. Let's self-destruct. |
| delete this; |
| callback.Run(NULL); |
| return; |
| } |
| InitWithWebContents(embedder_extension_id, |
| embedder_render_process_id, |
| guest_web_contents); |
| callback.Run(guest_web_contents); |
| } |
| |
| // static |
| void GuestViewBase::RegisterGuestViewTypes() { |
| ExtensionsAPIClient::Get()->RegisterGuestViewTypes(); |
| } |
| |
| } // namespace extensions |