Move ObjectContentType entirely to HTMLPlugInElement

third_party/WebKit/Source/core/html/HTMLPlugInElement.cpp

 /**
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 100 matching lines @@
 }
 
 void HTMLPlugInElement::SetFocused(bool focused, WebFocusType focus_type) {
   PluginView* plugin = OwnedPlugin();
   if (plugin)
     plugin->SetFocused(focused, focus_type);
   HTMLFrameOwnerElement::SetFocused(focused, focus_type);
 }
 
 bool HTMLPlugInElement::RequestObjectInternal(
-    const String& url,
-    const String& mime_type,
     const Vector<String>& param_names,
     const Vector<String>& param_values) {
-  if (url.IsEmpty() && mime_type.IsEmpty())
+  if (url_.IsEmpty() && service_type_.IsEmpty())
     return false;
 
-  if (ProtocolIsJavaScript(url))
+  if (ProtocolIsJavaScript(url_))
     return false;
 
-  KURL completed_url = url.IsEmpty() ? KURL() : GetDocument().CompleteURL(url);
-  if (!AllowedToLoadObject(completed_url, mime_type))
+  KURL completed_url =
+      url_.IsEmpty() ? KURL() : GetDocument().CompleteURL(url_);
+  if (!AllowedToLoadObject(completed_url, service_type_))
     return false;
 
-  bool use_fallback;
-  if (!ShouldUsePlugin(completed_url, mime_type, HasFallbackContent(),
-                       use_fallback)) {
+  ObjectContentType object_type = GetObjectContentType();
+  if (object_type == ObjectContentType::kFrame ||
+      object_type == ObjectContentType::kImage) {
     // If the plugin element already contains a subframe,
     // loadOrRedirectSubframe will re-use it. Otherwise, it will create a
     // new frame and set it as the LayoutEmbeddedContent's EmbeddedContentView,
     // causing what was previously in the EmbeddedContentView to be torn down.
     return LoadOrRedirectSubframe(completed_url, GetNameAttribute(), true);
   }
 
-  return LoadPlugin(completed_url, mime_type, param_names, param_values,
+  // If an object's content can't be handled and it has no fallback, let
+  // it be handled as a plugin to show the broken plugin icon.
+  bool use_fallback =
+      object_type == ObjectContentType::kNone && HasFallbackContent();
+  return LoadPlugin(completed_url, service_type_, param_names, param_values,
                     use_fallback, true);
 }
 
 bool HTMLPlugInElement::CanProcessDrag() const {
   return PluginEmbeddedContentView() &&
          PluginEmbeddedContentView()->CanProcessDrag();
 }
 
 bool HTMLPlugInElement::CanStartSelection() const {
   return UseFallbackContent() && Node::CanStartSelection();
@@ skipping 31 matching lines @@
     }
     return;
   }
 
   if (IsImageType()) {
     if (!image_loader_)
       image_loader_ = HTMLImageLoader::Create(this);
     image_loader_->UpdateFromElement();
   } else if (NeedsPluginUpdate() && !GetLayoutEmbeddedItem().IsNull() &&
              !GetLayoutEmbeddedItem().ShowsUnavailablePluginIndicator() &&
-             !WouldLoadAsNetscapePlugin(url_, service_type_) &&
+             GetObjectContentType() != ObjectContentType::kPlugin &&
              !is_delaying_load_event_) {
     is_delaying_load_event_ = true;
     GetDocument().IncrementLoadEventDelayCount();
     GetDocument().LoadPluginsSoon();
   }
 }
 
 void HTMLPlugInElement::UpdatePlugin() {
   UpdatePluginInternal();
   if (is_delaying_load_event_) {
@@ skipping 254 matching lines @@
 bool HTMLPlugInElement::LayoutObjectIsFocusable() const {
   if (HTMLFrameOwnerElement::SupportsFocus() &&
       HTMLFrameOwnerElement::LayoutObjectIsFocusable())
     return true;
 
   if (UseFallbackContent() || !HTMLFrameOwnerElement::LayoutObjectIsFocusable())
     return false;
   return plugin_is_available_;
 }
 
+HTMLPlugInElement::ObjectContentType HTMLPlugInElement::GetObjectContentType() {
+  String mime_type = service_type_;
+  KURL url = GetDocument().CompleteURL(url_);
+  if (mime_type.IsEmpty()) {
+    // Try to guess the MIME type based off the extension.
+    String filename = url.LastPathComponent();
+    int extension_pos = filename.ReverseFind('.');
+    if (extension_pos >= 0) {
+      String extension = filename.Substring(extension_pos + 1);
+      mime_type = MIMETypeRegistry::GetWellKnownMIMETypeForExtension(extension);
+    }
+
+    if (mime_type.IsEmpty())
+      return ObjectContentType::kFrame;
+  }
+
+  // If Chrome is started with the --disable-plugins switch, pluginData is 0.
+  PluginData* plugin_data = GetDocument().GetFrame()->GetPluginData();
+  bool plugin_supports_mime_type =
+      plugin_data && plugin_data->SupportsMimeType(mime_type);
+
+  if (MIMETypeRegistry::IsSupportedImageMIMEType(mime_type)) {
+    return should_prefer_plug_ins_for_images_ && plugin_supports_mime_type
+               ? ObjectContentType::kPlugin
+               : ObjectContentType::kImage;
+  }
+
+  if (plugin_supports_mime_type)
+    return ObjectContentType::kPlugin;
+  if (MIMETypeRegistry::IsSupportedNonImageMIMEType(mime_type))
+    return ObjectContentType::kFrame;
+  return ObjectContentType::kNone;
+}
+
 bool HTMLPlugInElement::IsImageType() {
   if (service_type_.IsEmpty() && ProtocolIs(url_, "data"))
     service_type_ = MimeTypeFromDataURL(url_);
 
-  if (LocalFrame* frame = GetDocument().GetFrame()) {
-    KURL completed_url = GetDocument().CompleteURL(url_);
-    return frame->Loader().Client()->GetObjectContentType(
-               completed_url, service_type_, ShouldPreferPlugInsForImages()) ==
-           kObjectContentImage;
-  }
-
+  if (GetDocument().GetFrame())
+    return GetObjectContentType() == ObjectContentType::kImage;
   return Image::SupportsType(service_type_);
 }
 
 LayoutEmbeddedItem HTMLPlugInElement::GetLayoutEmbeddedItem() const {
   // HTMLObjectElement and HTMLEmbedElement may return arbitrary layoutObjects
   // when using fallback content.
   if (!GetLayoutObject() || !GetLayoutObject()->IsEmbeddedObject())
     return LayoutEmbeddedItem(nullptr);
   return LayoutEmbeddedItem(ToLayoutEmbeddedObject(GetLayoutObject()));
 }
 
 // We don't use m_url, as it may not be the final URL that the object loads,
 // depending on <param> values.
 bool HTMLPlugInElement::AllowedToLoadFrameURL(const String& url) {
   KURL complete_url = GetDocument().CompleteURL(url);
   return !(ContentFrame() && complete_url.ProtocolIsJavaScript() &&
            !GetDocument().GetSecurityOrigin()->CanAccess(
                ContentFrame()->GetSecurityContext()->GetSecurityOrigin()));
 }
 
-// We don't use m_url, or m_serviceType as they may not be the final values
-// that <object> uses depending on <param> values.
-bool HTMLPlugInElement::WouldLoadAsNetscapePlugin(const String& url,
-                                                  const String& service_type) {
-  DCHECK(GetDocument().GetFrame());
-  KURL completed_url;
-  if (!url.IsEmpty())
-    completed_url = GetDocument().CompleteURL(url);
-  return GetDocument().GetFrame()->Loader().Client()->GetObjectContentType(
-             completed_url, service_type, ShouldPreferPlugInsForImages()) ==
-         kObjectContentNetscapePlugin;
-}
-
-bool HTMLPlugInElement::RequestObject(const String& url,
-                                      const String& mime_type,
-                                      const Vector<String>& param_names,
+bool HTMLPlugInElement::RequestObject(const Vector<String>& param_names,
                                       const Vector<String>& param_values) {
-  bool result =
-      RequestObjectInternal(url, mime_type, param_names, param_values);
+  bool result = RequestObjectInternal(param_names, param_values);
 
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, result_histogram,
       ("Plugin.RequestObjectResult", kPluginRequestObjectResultMax));
   result_histogram.Count(result ? kPluginRequestObjectResultSuccess
                                 : kPluginRequestObjectResultFailure);
 
   return result;
 }
 
@@ skipping 54 matching lines @@
   // Make sure any input event handlers introduced by the plugin are taken into
   // account.
   if (Page* page = GetDocument().GetFrame()->GetPage()) {
     if (ScrollingCoordinator* scrolling_coordinator =
             page->GetScrollingCoordinator())
       scrolling_coordinator->NotifyGeometryChanged();
   }
   return true;
 }
 
-bool HTMLPlugInElement::ShouldUsePlugin(const KURL& url,
-                                        const String& mime_type,
-                                        bool has_fallback,
-                                        bool& use_fallback) {
-  ObjectContentType object_type =
-      GetDocument().GetFrame()->Loader().Client()->GetObjectContentType(
-          url, mime_type, ShouldPreferPlugInsForImages());
-  // If an object's content can't be handled and it has no fallback, let
-  // it be handled as a plugin to show the broken plugin icon.
-  use_fallback = object_type == kObjectContentNone && has_fallback;
-  return object_type == kObjectContentNone ||
-         object_type == kObjectContentNetscapePlugin;
-}
-
 void HTMLPlugInElement::DispatchErrorEvent() {
   if (GetDocument().IsPluginDocument() && GetDocument().LocalOwner())
     GetDocument().LocalOwner()->DispatchEvent(
         Event::Create(EventTypeNames::error));
   else
     DispatchEvent(Event::Create(EventTypeNames::error));
 }
 
 bool HTMLPlugInElement::AllowedToLoadObject(const KURL& url,
                                             const String& mime_type) {
@@ skipping 56 matching lines @@
 
 void HTMLPlugInElement::LazyReattachIfNeeded() {
   if (!UseFallbackContent() && NeedsPluginUpdate() && GetLayoutObject() &&
       !IsImageType()) {
     LazyReattachIfAttached();
     SetPersistedPlugin(nullptr);
   }
 }
 
 }  // namespace blink