Save As for content retrieved via POST works in most circumstances.

content/browser/download/download_manager_impl.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/download/download_manager_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 18 matching lines @@
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/download_query.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents_delegate.h"
+#include "net/base/upload_data.h"
 
 // TODO(benjhayden): Change this to DCHECK when we have more debugging
 // information from the next dev cycle, before the next stable/beta branch is
 // cut, in order to prevent unnecessary crashes on those channels. If we still
 // don't have root cause before the dev cycle after the next stable/beta
 // releases, uncomment it out to re-enable debugging checks. Whenever this macro
 // is toggled, the corresponding macro in download_database.cc should also
 // be toggled. When 96627 is fixed, this macro and all its usages can be
 // deleted or permanently changed to DCHECK as appropriate.
 #define CHECK_96627 CHECK
 
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::WebContents;
 
 namespace {
 
 // Param structs exist because base::Bind can only handle 6 args.
 struct URLParams {
-  URLParams(const GURL& url, const GURL& referrer)
-    : url_(url), referrer_(referrer) {}
+  URLParams(const GURL& url, const GURL& referrer, int64 post_id)
+    : url_(url), referrer_(referrer), post_id_(post_id) {}
   GURL url_;
   GURL referrer_;
+  int64 post_id_;
 };
 
 struct RenderParams {
   RenderParams(int rpi, int rvi)
     : render_process_id_(rpi), render_view_id_(rvi) {}
   int render_process_id_;
   int render_view_id_;
 };
 
 void BeginDownload(const URLParams& url_params,
                    bool prefer_cache,
                    const DownloadSaveInfo& save_info,
                    ResourceDispatcherHost* resource_dispatcher_host,
                    const RenderParams& render_params,
                    const content::ResourceContext* context) {
   scoped_ptr<net::URLRequest> request(
       new net::URLRequest(url_params.url_, resource_dispatcher_host));
   request->set_referrer(url_params.referrer_.spec());
+  if (url_params.post_id_ >= 0) {

[Randy Smith (Not in Mondays), 2012/02/02 19:46:10]

If we decide that we eventually want to support POST with bodies that won't hit
in cache (see related comment), there should be a TODO comment here.

[cbentzel, 2012/02/03 15:54:47]

Done.

+    // The POST in this case does not have an actual body, and only works
+    // when retrieving data from cache.
+    DCHECK(prefer_cache);
+    request->set_method("POST");
+    scoped_refptr<net::UploadData> upload_data = new net::UploadData();
+    upload_data->set_identifier(url_params.post_id_);
+    request->set_upload(upload_data);
+  }
   resource_dispatcher_host->BeginDownload(
       request.Pass(), prefer_cache, save_info,
       DownloadResourceHandler::OnStartedCallback(),
       render_params.render_process_id_,
       render_params.render_view_id_,
       *context);
 }
 
 class MapValueIteratorAdapter {
  public:
@@ skipping 737 matching lines @@
 }
 
 // Initiate a download of a specific URL. We send the request to the
 // ResourceDispatcherHost, and let it send us responses like a regular
 // download.
 void DownloadManagerImpl::DownloadUrl(
     const GURL& url,
     const GURL& referrer,
     const std::string& referrer_charset,
     bool prefer_cache,
+    int64 post_id,
     const DownloadSaveInfo& save_info,
     WebContents* web_contents) {
   ResourceDispatcherHost* resource_dispatcher_host =
       ResourceDispatcherHost::Get();
 
   // We send a pointer to content::ResourceContext, instead of the usual
   // reference, so that a copy of the object isn't made.
   // base::Bind can't handle 7 args, so we use URLParams and RenderParams.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &BeginDownload,
-          URLParams(url, referrer),
+          URLParams(url, referrer, post_id),
           prefer_cache,
           save_info,
           resource_dispatcher_host,
           RenderParams(web_contents->GetRenderProcessHost()->GetID(),
                        web_contents->GetRenderViewHost()->routing_id()),
           &web_contents->GetBrowserContext()->GetResourceContext()));
 }
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
@@ skipping 346 matching lines @@
        it != history_downloads_.end(); ++it) {
     if (it->second->IsComplete() && !it->second->GetOpened())
       ++num_unopened;
   }
   download_stats::RecordOpensOutstanding(num_unopened);
 }
 
 void DownloadManagerImpl::SetFileManager(DownloadFileManager* file_manager) {
   file_manager_ = file_manager;
 }