Revert of Ensuring interception of stream get determined by plugin path before checking mime type.

content/browser/loader/buffered_resource_handler.cc

 // Copyright (c) 2012 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 "content/browser/loader/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 279 matching lines @@
                          type_hint, &new_type);
 
   // SniffMimeType() returns false if there is not enough data to determine
   // the mime type. However, even if it returns false, it returns a new type
   // that is probably better than the current one.
   response_->head.mime_type.assign(new_type);
 
   return made_final_decision;
 }
 
-bool BufferedResourceHandler::IsHandledByPlugin(bool* defer,
-                                                bool* request_handled) {
-#if defined(ENABLE_PLUGINS)
-  bool stale;
-  WebPluginInfo plugin;
-  bool allow_wildcard = false;
-  ResourceRequestInfoImpl* info = GetRequestInfo();
-  bool has_plugin = plugin_service_->GetPluginInfo(
-      info->GetChildID(), info->GetRenderFrameID(), info->GetContext(),
-      request()->url(), GURL(), response_->head.mime_type, allow_wildcard,
-      &stale, &plugin, NULL);
-
-  if (stale) {
-    // Refresh the plugins asynchronously.
-    plugin_service_->GetPlugins(
-        base::Bind(&BufferedResourceHandler::OnPluginsLoaded,
-                   weak_ptr_factory_.GetWeakPtr()));
-    request()->LogBlockedBy("BufferedResourceHandler");
-    *defer = true;
-    return true;
-  }
-
-  if (has_plugin) {
-    if (plugin.type == WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN) {
-      // If it is a MimeHandlerView plugin, intercept the stream.
-      std::string payload;
-      scoped_ptr<ResourceHandler> handler(host_->MaybeInterceptAsStream(
-          plugin.path, request(), response_.get(), &payload));
-      if (handler) {
-        *request_handled = UseAlternateNextHandler(handler.Pass(), payload);
-        return true;
-      }
-      return false;
-    } else {
-      return true;
-    }
-  }
-
-  // If execution reaches here then we should try intercepting the stream for
-  // the old streamsPrivate extensions API. This API is deprecated and should
-  // go away.
-  std::string payload;
-  scoped_ptr<ResourceHandler> handler(host_->MaybeInterceptAsStream(
-      base::FilePath(), request(), response_.get(), &payload));
-  if (handler) {
-    *request_handled = UseAlternateNextHandler(handler.Pass(), payload);
-    return true;
-  }
-#endif
-  return false;
-}
-
 bool BufferedResourceHandler::SelectNextHandler(bool* defer) {
   DCHECK(!response_->head.mime_type.empty());
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
   const std::string& mime_type = response_->head.mime_type;
 
   if (net::IsSupportedCertificateMimeType(mime_type)) {
     // Install certificate file.
     info->set_is_download(true);
     scoped_ptr<ResourceHandler> handler(
         new CertificateResourceHandler(request()));
     return UseAlternateNextHandler(handler.Pass(), std::string());
   }
 
   // Allow requests for object/embed tags to be intercepted as streams.
   if (info->GetResourceType() == content::RESOURCE_TYPE_OBJECT) {
     DCHECK(!info->allow_download());
-
-    bool request_handled = true;
-    bool handled_by_plugin = IsHandledByPlugin(defer, &request_handled);
-    if (!request_handled)
-      return false;
-    if (handled_by_plugin)
-      return true;
+    std::string payload;
+    scoped_ptr<ResourceHandler> handler(
+        host_->MaybeInterceptAsStream(request(), response_.get(), &payload));
+    if (handler) {
+      DCHECK(!net::IsSupportedMimeType(mime_type));
+      return UseAlternateNextHandler(handler.Pass(), payload);
+    }
   }
 
   if (!info->allow_download())
     return true;
 
   // info->allow_download() == true implies
   // info->GetResourceType() == RESOURCE_TYPE_MAIN_FRAME or
   // info->GetResourceType() == RESOURCE_TYPE_SUB_FRAME.
   DCHECK(info->GetResourceType() == RESOURCE_TYPE_MAIN_FRAME ||
          info->GetResourceType() == RESOURCE_TYPE_SUB_FRAME);
 
   bool must_download = MustDownload();
   if (!must_download) {
     if (net::IsSupportedMimeType(mime_type))
       return true;
 
-    bool request_handled = true;
-    bool handled_by_plugin = IsHandledByPlugin(defer, &request_handled);
-    if (!request_handled)
-      return false;
-    if (handled_by_plugin)
+    std::string payload;
+    scoped_ptr<ResourceHandler> handler(
+        host_->MaybeInterceptAsStream(request(), response_.get(), &payload));
+    if (handler) {
+      return UseAlternateNextHandler(handler.Pass(), payload);
+    }
+
+#if defined(ENABLE_PLUGINS)
+    bool stale;
+    bool has_plugin = HasSupportingPlugin(&stale);
+    if (stale) {
+      // Refresh the plugins asynchronously.
+      plugin_service_->GetPlugins(
+          base::Bind(&BufferedResourceHandler::OnPluginsLoaded,
+                     weak_ptr_factory_.GetWeakPtr()));
+      request()->LogBlockedBy("BufferedResourceHandler");
+      *defer = true;
       return true;
+    }
+    if (has_plugin)
+      return true;
+#endif
   }
 
   // Install download handler
   info->set_is_download(true);
   scoped_ptr<ResourceHandler> handler(
       host_->CreateResourceHandlerForDownload(
           request(),
           true,  // is_content_initiated
           must_download,
           DownloadItem::kInvalidId,
@@ skipping 96 matching lines @@
              host_->delegate()->ShouldForceDownloadResource(
                  request()->url(), response_->head.mime_type)) {
     must_download_ = true;
   } else {
     must_download_ = false;
   }
 
   return must_download_;
 }
 
+bool BufferedResourceHandler::HasSupportingPlugin(bool* stale) {
+#if defined(ENABLE_PLUGINS)
+  ResourceRequestInfoImpl* info = GetRequestInfo();
+
+  bool allow_wildcard = false;
+  WebPluginInfo plugin;
+  return plugin_service_->GetPluginInfo(
+      info->GetChildID(), info->GetRenderFrameID(), info->GetContext(),
+      request()->url(), GURL(), response_->head.mime_type, allow_wildcard,
+      stale, &plugin, NULL);
+#else
+  if (stale)
+    *stale = false;
+  return false;
+#endif
+}
+
 bool BufferedResourceHandler::CopyReadBufferToNextHandler() {
   if (!read_buffer_.get())
     return true;
 
   scoped_refptr<net::IOBuffer> buf;
   int buf_len = 0;
   if (!next_handler_->OnWillRead(&buf, &buf_len, bytes_read_))
     return false;
 
   CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
   memcpy(buf->data(), read_buffer_->data(), bytes_read_);
   return true;
 }
 
 void BufferedResourceHandler::OnPluginsLoaded(
     const std::vector<WebPluginInfo>& plugins) {
   request()->LogUnblocked();
   bool defer = false;
   if (!ProcessResponse(&defer)) {
     controller()->Cancel();
   } else if (!defer) {
     controller()->Resume();
   }
 }
 
 }  // namespace content