extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "content/public/browser/browser_thread.h"
   9 #include "content/public/browser/host_zoom_map.h"
  10 #include "content/public/browser/render_process_host.h"
  11 #include "content/public/browser/stream_handle.h"
  12 #include "content/public/browser/stream_info.h"
  13 #include "content/public/common/service_registry.h"
  14 #include "content/public/common/url_constants.h"
  15 #include "extensions/browser/api/extensions_api_client.h"
  16 #include "extensions/browser/api/mime_handler_private/mime_handler_private.h"
  17 #include "extensions/browser/extension_registry.h"
  18 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_stream_manager.h"
  19 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_constants.h"
  20 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest_delegate.h"
  21 #include "extensions/browser/process_manager.h"
  22 #include "extensions/common/constants.h"
  23 #include "extensions/common/extension_messages.h"
  24 #include "extensions/common/guest_view/guest_view_constants.h"
  25 #include "extensions/common/guest_view/guest_view_messages.h"
  26 #include "extensions/strings/grit/extensions_strings.h"
  27 #include "ipc/ipc_message_macros.h"
  28 #include "net/base/url_util.h"
  29
  30 using content::WebContents;
  31
  32 namespace extensions {
  33
  34 StreamContainer::StreamContainer(scoped_ptr<content::StreamInfo> stream,
  35                                  int tab_id,
  36                                  bool embedded,
  37                                  const GURL& handler_url,
  38                                  const std::string& extension_id)
  39     : stream_(stream.Pass()),
  40       embedded_(embedded),
  41       tab_id_(tab_id),
  42       handler_url_(handler_url),
  43       extension_id_(extension_id),
  44       weak_factory_(this) {
  45   DCHECK(stream_);
  46 }
  47
  48 StreamContainer::~StreamContainer() {
  49 }
  50
  51 void StreamContainer::Abort(const base::Closure& callback) {
  52   if (!stream_->handle) {
  53     callback.Run();
  54     return;
  55   }
  56   stream_->handle->AddCloseListener(callback);
  57   stream_->handle.reset();
  58 }
  59
  60 base::WeakPtr<StreamContainer> StreamContainer::GetWeakPtr() {
  61   return weak_factory_.GetWeakPtr();
  62 }
  63
  64 // static
  65 const char MimeHandlerViewGuest::Type[] = "mimehandler";
  66
  67 // static
  68 GuestViewBase* MimeHandlerViewGuest::Create(
  69     content::WebContents* owner_web_contents) {
  70   return new MimeHandlerViewGuest(owner_web_contents);
  71 }
  72
  73 MimeHandlerViewGuest::MimeHandlerViewGuest(
  74     content::WebContents* owner_web_contents)
  75     : GuestView<MimeHandlerViewGuest>(owner_web_contents),
  76       delegate_(ExtensionsAPIClient::Get()->CreateMimeHandlerViewGuestDelegate(
  77           this)) {
  78 }
  79
  80 MimeHandlerViewGuest::~MimeHandlerViewGuest() {
  81 }
  82
  83 WindowController* MimeHandlerViewGuest::GetExtensionWindowController() const {
  84   return nullptr;
  85 }
  86
  87 WebContents* MimeHandlerViewGuest::GetAssociatedWebContents() const {
  88   return web_contents();
  89 }
  90
  91 const char* MimeHandlerViewGuest::GetAPINamespace() const {
  92   return "mimeHandlerViewGuestInternal";
  93 }
  94
  95 int MimeHandlerViewGuest::GetTaskPrefix() const {
  96   return IDS_EXTENSION_TASK_MANAGER_MIMEHANDLERVIEW_TAG_PREFIX;
  97 }
  98
  99 void MimeHandlerViewGuest::CreateWebContents(
 100     const base::DictionaryValue& create_params,
 101     const WebContentsCreatedCallback& callback) {
 102   create_params.GetString(mime_handler_view::kViewId, &view_id_);
 103   if (view_id_.empty()) {
 104     callback.Run(nullptr);
 105     return;
 106   }
 107   stream_ =
 108       MimeHandlerStreamManager::Get(browser_context())->ReleaseStream(view_id_);
 109   if (!stream_) {
 110     callback.Run(nullptr);
 111     return;
 112   }
 113   const Extension* mime_handler_extension =
 114       // TODO(lazyboy): Do we need handle the case where the extension is
 115       // terminated (ExtensionRegistry::TERMINATED)?
 116       ExtensionRegistry::Get(browser_context())
 117           ->enabled_extensions()
 118           .GetByID(stream_->extension_id());
 119   if (!mime_handler_extension) {
 120     LOG(ERROR) << "Extension for mime_type not found, mime_type = "
 121                << stream_->stream_info()->mime_type;
 122     callback.Run(nullptr);
 123     return;
 124   }
 125
 126   // Use the mime handler extension's SiteInstance to create the guest so it
 127   // goes under the same process as the extension.
 128   ProcessManager* process_manager = ProcessManager::Get(browser_context());
 129   content::SiteInstance* guest_site_instance =
 130       process_manager->GetSiteInstanceForURL(stream_->handler_url());
 131
 132   // Clear the zoom level for the mime handler extension. The extension is
 133   // responsible for managing its own zoom. This is necessary for OOP PDF, as
 134   // otherwise the UI is zoomed and the calculations to determine the PDF size
 135   // mix zoomed and unzoomed units.
 136   content::HostZoomMap::Get(guest_site_instance)
 137       ->SetZoomLevelForHostAndScheme(kExtensionScheme, stream_->extension_id(),
 138                                      0);
 139
 140   WebContents::CreateParams params(browser_context(), guest_site_instance);
 141   params.guest_delegate = this;
 142   callback.Run(WebContents::Create(params));
 143 }
 144
 145 void MimeHandlerViewGuest::DidAttachToEmbedder() {
 146   web_contents()->GetController().LoadURL(
 147       stream_->handler_url(), content::Referrer(),
 148       ui::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());
 149   web_contents()->GetMainFrame()->GetServiceRegistry()->AddService(
 150       base::Bind(&MimeHandlerServiceImpl::Create, stream_->GetWeakPtr()));
 151 }
 152
 153 void MimeHandlerViewGuest::DidInitialize(
 154     const base::DictionaryValue& create_params) {
 155   extension_function_dispatcher_.reset(
 156       new ExtensionFunctionDispatcher(browser_context(), this));
 157   if (delegate_)
 158     delegate_->AttachHelpers();
 159 }
 160
 161 bool MimeHandlerViewGuest::ZoomPropagatesFromEmbedderToGuest() const {
 162   return false;
 163 }
 164
 165 bool MimeHandlerViewGuest::Find(int request_id,
 166                                 const base::string16& search_text,
 167                                 const blink::WebFindOptions& options) {
 168   if (is_full_page_plugin()) {
 169     web_contents()->Find(request_id, search_text, options);
 170     return true;
 171   }
 172   return false;
 173 }
 174
 175 content::WebContents* MimeHandlerViewGuest::OpenURLFromTab(
 176     content::WebContents* source,
 177     const content::OpenURLParams& params) {
 178   return embedder_web_contents()->GetDelegate()->OpenURLFromTab(
 179       embedder_web_contents(), params);
 180 }
 181
 182 bool MimeHandlerViewGuest::HandleContextMenu(
 183     const content::ContextMenuParams& params) {
 184   if (delegate_)
 185     return delegate_->HandleContextMenu(web_contents(), params);
 186
 187   return false;
 188 }
 189
 190 void MimeHandlerViewGuest::FindReply(content::WebContents* web_contents,
 191                                      int request_id,
 192                                      int number_of_matches,
 193                                      const gfx::Rect& selection_rect,
 194                                      int active_match_ordinal,
 195                                      bool final_update) {
 196   if (!attached() || !embedder_web_contents()->GetDelegate())
 197     return;
 198
 199   embedder_web_contents()->GetDelegate()->FindReply(embedder_web_contents(),
 200                                                     request_id,
 201                                                     number_of_matches,
 202                                                     selection_rect,
 203                                                     active_match_ordinal,
 204                                                     final_update);
 205 }
 206
 207 bool MimeHandlerViewGuest::SaveFrame(const GURL& url,
 208                                      const content::Referrer& referrer) {
 209   if (!attached())
 210     return false;
 211
 212   embedder_web_contents()->SaveFrame(stream_->stream_info()->original_url,
 213                                      referrer);
 214   return true;
 215 }
 216
 217 void MimeHandlerViewGuest::DocumentOnLoadCompletedInMainFrame() {
 218   embedder_web_contents()->Send(
 219       new GuestViewMsg_MimeHandlerViewGuestOnLoadCompleted(
 220           element_instance_id()));
 221 }
 222
 223 bool MimeHandlerViewGuest::OnMessageReceived(const IPC::Message& message) {
 224   bool handled = true;
 225   IPC_BEGIN_MESSAGE_MAP(MimeHandlerViewGuest, message)
 226     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
 227     IPC_MESSAGE_UNHANDLED(handled = false)
 228   IPC_END_MESSAGE_MAP()
 229   return handled;
 230 }
 231
 232 base::WeakPtr<StreamContainer> MimeHandlerViewGuest::GetStream() const {
 233   if (!stream_)
 234     return base::WeakPtr<StreamContainer>();
 235   return stream_->GetWeakPtr();
 236 }
 237
 238 void MimeHandlerViewGuest::OnRequest(
 239     const ExtensionHostMsg_Request_Params& params) {
 240   if (extension_function_dispatcher_) {
 241     extension_function_dispatcher_->Dispatch(
 242         params, web_contents()->GetRenderViewHost());
 243   }
 244 }
 245
 246 }  // namespace extensions