Move FTP LIST parsing code to the renderer process.

webkit/glue/weburlloader_impl.cc

 // Copyright (c) 2006-2009 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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/glue/weburlloader_impl.h"
 
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/data_url.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/api/public/WebHTTPHeaderVisitor.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLError.h"
 #include "webkit/api/public/WebURLLoaderClient.h"
 #include "webkit/api/public/WebURLRequest.h"
 #include "webkit/api/public/WebURLResponse.h"
+#include "webkit/glue/ftp_directory_listing_response_delegate.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/multipart_response_delegate.h"
 #include "webkit/glue/resource_loader_bridge.h"
 #include "webkit/glue/webkit_glue.h"
 
 using base::Time;
 using base::TimeDelta;
 using WebKit::WebData;
 using WebKit::WebHTTPBody;
 using WebKit::WebHTTPHeaderVisitor;
@@ skipping 184 matching lines @@
  private:
   friend class base::RefCounted<Context>;
   ~Context() {}
 
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
   WebURLRequest request_;
   WebURLLoaderClient* client_;
   scoped_ptr<ResourceLoaderBridge> bridge_;
+  scoped_ptr<FtpDirectoryListingResponseDelegate> ftp_listing_delegate_;
   scoped_ptr<MultipartResponseDelegate> multipart_delegate_;
   int64 expected_content_length_;
 };
 
 WebURLLoaderImpl::Context::Context(WebURLLoaderImpl* loader)
     : loader_(loader),
       client_(NULL) {
 }
 
 void WebURLLoaderImpl::Context::Cancel() {
@@ skipping 182 matching lines @@
   if (!client_)
     return;
 
   WebURLResponse response;
   response.initialize();
   PopulateURLResponse(request_.url(), info, &response);
   response.setIsContentFiltered(content_filtered);
 
   expected_content_length_ = response.expectedContentLength();
 
+  if (info.mime_type == "text/vnd.chromium.ftp-dir")

[eroman, 2009/09/23 21:14:49]

I am still not convinced that we want to expose this mime type for other server
responses to use... But I guess if Darin is OK with it then it's fine.

+    response.setMIMEType(WebString::fromUTF8("text/html"));

[eroman, 2009/09/23 21:14:49]

should we additionally specify the charset? Or is the listing HTML going to be
purely ISO-8859-1?

+
   client_->didReceiveResponse(loader_, response);
 
-  // we may have been cancelled after didReceiveResponse, which would leave us
-  // without a client and therefore without much need to do multipart handling.
+  // We may have been cancelled after didReceiveResponse, which would leave us
+  // without a client and therefore without much need to do further handling.
   if (!client_)
     return;
 
+  DCHECK(!ftp_listing_delegate_.get());
   DCHECK(!multipart_delegate_.get());
   if (info.headers && info.mime_type == "multipart/x-mixed-replace") {
     std::string content_type;
     info.headers->EnumerateHeader(NULL, "content-type", &content_type);
 
     std::string boundary = net::GetHeaderParamValue(content_type, "boundary");
     TrimString(boundary, " \"", &boundary);
 
     // If there's no boundary, just handle the request normally.  In the gecko
     // code, nsMultiMixedConv::OnStartRequest throws an exception.
     if (!boundary.empty()) {
       multipart_delegate_.reset(
           new MultipartResponseDelegate(client_, loader_, response, boundary));
     }
+  } else if (info.mime_type == "text/vnd.chromium.ftp-dir") {
+    ftp_listing_delegate_.reset(
+        new FtpDirectoryListingResponseDelegate(client_, loader_, response));
   }
 }
 
 void WebURLLoaderImpl::Context::OnReceivedData(const char* data, int len) {
   if (!client_)
     return;
 
-  if (multipart_delegate_.get()) {
+  if (ftp_listing_delegate_.get()) {
+    // The FTP listing delegate will make the appropriate calls to
+    // client_->didReceiveData and client_->didReceiveResponse.
+    ftp_listing_delegate_->OnReceivedData(data, len);
+  } else if (multipart_delegate_.get()) {
     // The multipart delegate will make the appropriate calls to
     // client_->didReceiveData and client_->didReceiveResponse.
     multipart_delegate_->OnReceivedData(data, len);
   } else {
     client_->didReceiveData(loader_, data, len, expected_content_length_);
   }
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
     const URLRequestStatus& status,
     const std::string& security_info) {
-  if (multipart_delegate_.get()) {
+  if (ftp_listing_delegate_.get()) {
+    ftp_listing_delegate_->OnCompletedRequest();
+    ftp_listing_delegate_.reset(NULL);
+  } else if (multipart_delegate_.get()) {
     multipart_delegate_->OnCompletedRequest();
     multipart_delegate_.reset(NULL);
   }
 
   // Prevent any further IPC to the browser now that we're complete.
   bridge_.reset();
 
   if (client_) {
     if (status.status() != URLRequestStatus::SUCCESS) {
       int error_code;
@@ skipping 85 matching lines @@
 
 void WebURLLoaderImpl::cancel() {
   context_->Cancel();
 }
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 }  // namespace webkit_glue