Improve error handling in FtpDirectoryListingResponseDelegate.

content/child/ftp_directory_listing_response_delegate.cc

 // 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 "content/child/ftp_directory_listing_response_delegate.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/i18n/encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/child/weburlresponse_extradata_impl.h"
 #include "net/base/directory_listing.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/ftp/ftp_directory_listing_parser.h"
 #include "net/net_features.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
+#include "third_party/WebKit/public/platform/WebURLLoader.h"
 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
 
-using blink::WebURLLoader;
-using blink::WebURLLoaderClient;
-using blink::WebURLResponse;
 using net::FtpDirectoryListingEntry;
 
 namespace {
 
 base::string16 ConvertPathToUTF16(const std::string& path) {
   // Per RFC 2640, FTP servers should use UTF-8 or its proper subset ASCII,
   // but many old FTP servers use legacy encodings. Try UTF-8 first.
   if (base::IsStringUTF8(path))
     return base::UTF8ToUTF16(path);
 
@@ skipping 11 matching lines @@
 
   // Use system native encoding as the last resort.
   return base::WideToUTF16(base::SysNativeMBToWide(path));
 }
 
 }  // namespace
 
 namespace content {
 
 FtpDirectoryListingResponseDelegate::FtpDirectoryListingResponseDelegate(
-    WebURLLoaderClient* client,
-    WebURLLoader* loader,
-    const WebURLResponse& response)
-    : client_(client),
-      loader_(loader) {
+    blink::WebURLLoaderClient* client,
+    blink::WebURLLoader* loader,
+    const blink::WebURLResponse& response)
+    : client_(client), loader_(loader) {
   if (response.GetExtraData()) {
     // |extra_data| can be NULL during tests.
     WebURLResponseExtraDataImpl* extra_data =
         static_cast<WebURLResponseExtraDataImpl*>(response.GetExtraData());
     extra_data->set_is_ftp_directory_listing(true);
   }
   Init(response.Url());
 }
 
 void FtpDirectoryListingResponseDelegate::Cancel() {
   client_ = nullptr;
   loader_ = nullptr;
 }
 
 void FtpDirectoryListingResponseDelegate::OnReceivedData(const char* data,
                                                          int data_len) {
   buffer_.append(data, data_len);
 }
 
-void FtpDirectoryListingResponseDelegate::OnCompletedRequest() {
+void FtpDirectoryListingResponseDelegate::OnCompletedRequest(int error_code) {
   std::vector<FtpDirectoryListingEntry> entries;
   int rv = net::ERR_NOT_IMPLEMENTED;
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
-  rv = net::ParseFtpDirectoryListing(buffer_, base::Time::Now(), &entries);
+  if (error_code == net::OK)
+    rv = net::ParseFtpDirectoryListing(buffer_, base::Time::Now(), &entries);
+  else
+    rv = error_code;
 #endif
+  buffer_.clear();
   if (rv != net::OK) {
     SendDataToClient("<script>onListingParsingError();</script>\n");
+    if (loader_)
+      loader_->Cancel();
     return;
   }
   for (const FtpDirectoryListingEntry& entry : entries) {
     // Skip the current and parent directory entries in the listing. Our header
     // always includes them.
     if (base::EqualsASCII(entry.name, ".") ||
         base::EqualsASCII(entry.name, ".."))
       continue;
 
     bool is_directory = (entry.type == FtpDirectoryListingEntry::DIRECTORY);
@@ skipping 14 matching lines @@
       ConvertPathToUTF16(unescaped_path)));
 
   // If this isn't top level directory (i.e. the path isn't "/",)
   // add a link to the parent directory.
   if (response_url.path().length() > 1) {
     SendDataToClient("<script>onHasParentDirectory();</script>\n");
   }
 }
 
 void FtpDirectoryListingResponseDelegate::SendDataToClient(
-    const std::string& data) {
+    base::StringPiece data) {
   if (client_) {
     client_->DidReceiveData(data.data(), data.length());
   }
 }
 
 }  // namespace content