Content-Dispositon handling fix #2. Still WiP. Uploading as a check point....

webkit/glue/resource_handle_impl.cc

 // Copyright (c) 2006-2008 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.
 //
 // This file replaces WebCore/platform/network/win/ResourceHandleWin.cpp with a
 // platform-neutral implementation that simply defers almost entirely to
 // ResouceLoaderBridge.
 //
 // This uses the same ResourceHandle.h header file that the rest of WebKit
 // uses, allowing us to avoid complicated changes. Our specific things are
@@ skipping 117 matching lines @@
 
     pair<HTTPHeaderMap::iterator, bool> result =
         header_map->add(name_str, value_str);
     if (!result.second)
       result.first->second += ", " + value_str;
   }
 }
 
 static ResourceResponse MakeResourceResponse(
     const KURL& kurl,
-    const ResourceLoaderBridge::ResponseInfo& info) {
+    const ResourceLoaderBridge::ResponseInfo& info,
+    const std::string& disposition_fallback_charset) {
   int status_code = 0;
   long long expected_content_length = info.content_length;
   String status_text;
   HTTPHeaderMap header_map;
 
   // It's okay if there are no headers
   if (info.headers)
     ExtractInfoFromHeaders(info.headers,
                            &header_map,
                            &status_code,
                            &status_text,
                            &expected_content_length);
 
   // TODO(darin): We should leverage HttpResponseHeaders for this, and this
   // should be using the same code as ResourceDispatcherHost.
-  // TODO(jungshik): Figure out the actual value of the referrer charset and
-  // pass it to GetSuggestedFilename.
   std::wstring suggested_filename;
   if (info.headers) {
     std::string disp_val;
     if (info.headers->EnumerateHeader(NULL, "content-disposition", &disp_val)) {
       suggested_filename = net::GetSuggestedFilename(
-          webkit_glue::KURLToGURL(kurl), disp_val, "", std::wstring());
+          webkit_glue::KURLToGURL(kurl), disp_val,
+          disposition_fallback_charset, std::wstring());
     }
   }
 
   ResourceResponse response(kurl,
       webkit_glue::StdStringToString(info.mime_type),
       expected_content_length,
       webkit_glue::StdStringToString(info.charset),
       webkit_glue::StdWStringToString(suggested_filename));
 
   if (info.headers) {
@@ skipping 27 matching lines @@
   // WebKit doesn't provide a way for us to set expected content length after
   // calling the constructor, so we parse the headers first and then swap in
   // our HTTP header map. Ideally we would like a setter for expected content
   // length (perhaps by abstracting ResourceResponse interface into
   // ResourceResponseBase) but that would require forking.
   const_cast<HTTPHeaderMap*>(&response.httpHeaderFields())->swap(header_map);
 
   return response;
 }
 
+inline static std::string FallbackCharsetForFileName(
+    const ResourceRequest& request) {
+  return webkit_glue::StringToStdString(
+      request.contentDispositionFallbackEncoding());
+}
+
 class ResourceHandleInternal : public ResourceLoaderBridge::Peer {
  public:
   ResourceHandleInternal(ResourceHandle* job, const ResourceRequest& r,
                          ResourceHandleClient* c);
   ~ResourceHandleInternal();
 
   // If the response parameter is null, then an asynchronous load is started.
   bool Start(ResourceLoaderBridge::SyncLoadResponse* response);
 
   // Used to cancel an asynchronous load.
@@ skipping 190 matching lines @@
     return true;
   }
 
   // TODO(abarth): These are wrong!  I need to figure out how to get the right
   //               strings here.  See: http://crbug.com/8706
   std::string frame_origin =
       webkit_glue::StringToStdString(request_.mainDocumentURL().string());
   std::string main_frame_origin =
       webkit_glue::StringToStdString(request_.mainDocumentURL().string());
 
+  std::string fallback_charset = FallbackCharsetForFileName(request_);
+
   // TODO(darin): is latin1 really correct here?  It is if the strings are
   // already ASCII (i.e., if they are already escaped properly).
   // TODO(brettw) this should take parameter encoding into account when
   // creating the GURLs.
   bridge_.reset(ResourceLoaderBridge::Create(
       webkit_glue::CStringToStdString(method),
       url,
       webkit_glue::KURLToGURL(request_.policyURL()),
       referrer,
       frame_origin,
       main_frame_origin,
       webkit_glue::CStringToStdString(headerBuf.latin1()),
       load_flags_,
       requestor_pid,
       FromTargetType(request_.targetType()),
       request_.appCacheContextID(),
-      request_.requestorID()));
+      request_.requestorID(),
+      fallback_charset));
   if (!bridge_.get())
     return false;
 
   if (request_.httpBody()) {
     // GET and HEAD requests shouldn't have http bodies.
     DCHECK(method != "GET" && method != "HEAD");
     const Vector<FormDataElement>& elements = request_.httpBody()->elements();
     size_t n = elements.size();
     for (size_t i = 0; i < n; ++i) {
       const FormDataElement& e = elements[static_cast<unsigned>(i)];
@@ skipping 82 matching lines @@
 
   request_ = new_request;
 }
 
 void ResourceHandleInternal::OnReceivedResponse(
     const ResourceLoaderBridge::ResponseInfo& info,
     bool content_filtered) {
   DCHECK(pending_);
 
   // TODO(darin): need a way to properly initialize a ResourceResponse
-  ResourceResponse response = MakeResourceResponse(request_.url(), info);
+  std::string fallback_charset = FallbackCharsetForFileName(request_);
+  ResourceResponse response = MakeResourceResponse(request_.url(), info,
+                                                   fallback_charset);
   response.setIsContentFiltered(content_filtered);
 
   expected_content_length_ = response.expectedContentLength();
 
   if (client_)
     client_->didReceiveResponse(job_, response);
 
   // we may have been cancelled after didReceiveResponse, which would leave us
   // without a client and therefore without much need to do multipart handling.
 
@@ skipping 181 matching lines @@
   if (status != URLRequestStatus::SUCCESS &&
       status != URLRequestStatus::HANDLED_EXTERNALLY) {
     response = ResourceResponse(kurl, String(), 0, String(), String());
     error = ResourceError(net::kErrorDomain,
                           sync_load_response.status.os_error(),
                           kurl.string(),
                           String() /* localized description */);
     return;
   }
 
-  response = MakeResourceResponse(kurl, sync_load_response);
+  std::string fallback_charset = FallbackCharsetForFileName(request);
+  response = MakeResourceResponse(kurl, sync_load_response, fallback_charset);
 
   data.clear();
   data.append(sync_load_response.data.data(),
               sync_load_response.data.size());
 }
 
 // static
 bool ResourceHandle::willLoadFromCache(ResourceRequest& request) {
   //
   // This method is used to determine if a POST request can be repeated from
   // cache, but you cannot really know until you actually try to read from the
   // cache.  Even if we checked now, something else could come along and wipe
   // out the cache entry by the time we fetch it.
   //
   // So, we always say yes here, which allows us to generate an ERR_CACHE_MISS
   // if the request cannot be serviced from cache.  We force the 'DontLoad'
   // cache policy at this point to ensure that we never hit the network for
   // this request.
   //
   DCHECK(request.httpMethod() == "POST");
   request.setCachePolicy(ReturnCacheDataDontLoad);
   return true;
 }
 
 }  // namespace WebCore