Revert r52848 - Linux x64 compile failure.

chrome/browser/download/download_manager.cc

 // Copyright (c) 2010 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 "chrome/browser/download/download_manager.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 386 matching lines @@
 // history system of a new download. Since this method can be called while the
 // history service thread is still reading the persistent state, we do not
 // insert the new DownloadItem into 'downloads_' or inform our observers at this
 // point. OnCreateDatabaseEntryComplete() handles that finalization of the the
 // download creation as a callback from the history thread.
 void DownloadManager::StartDownload(DownloadCreateInfo* info) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(info);
 
   // Check whether this download is for an extension install or not.
-  // Allow extensions to be explicitly saved.
-  if (!info->prompt_user_for_save_location) {
+  if (!info->save_as) {  // Allow extensions to be explicitly saved.
     if (UserScript::HasUserScriptFileExtension(info->url) ||
         info->mime_type == Extension::kMimeType)
       info->is_extension_install = true;
   }
 
   if (info->save_info.file_path.empty()) {
     FilePath generated_name;
     GenerateFileNameFromInfo(info, &generated_name);
 
     // Freeze the user's preference for showing a Save As dialog.  We're going
     // to bounce around a bunch of threads and we don't want to worry about race
     // conditions where the user changes this pref out from under us.
     if (*prompt_for_download_) {
       // But ignore the user's preference for the following scenarios:
       // 1) Extension installation. Note that we only care here about the case
       //    where an extension is installed, not when one is downloaded with
       //    "save as...".
       // 2) Filetypes marked "always open." If the user just wants this file
       //    opened, don't bother asking where to keep it.
       if (!info->is_extension_install &&
           !ShouldOpenFileBasedOnExtension(generated_name))
-        info->prompt_user_for_save_location = true;
+        info->save_as = true;
     }
 
     // Determine the proper path for a download, by either one of the following:
     // 1) using the default download directory.
     // 2) prompting the user.
-    if (info->prompt_user_for_save_location && !last_download_path_.empty())
+    if (info->save_as && !last_download_path_.empty())
       info->suggested_path = last_download_path_;
     else
       info->suggested_path = download_path();
     info->suggested_path = info->suggested_path.Append(generated_name);
   } else {
     info->suggested_path = info->save_info.file_path;
   }
 
-  if (!info->prompt_user_for_save_location &&
-      info->save_info.file_path.empty()) {
+  if (!info->save_as && info->save_info.file_path.empty()) {
     // Downloads can be marked as dangerous for two reasons:
     // a) They have a dangerous-looking filename
     // b) They are an extension that is not from the gallery
     if (IsDangerous(info->suggested_path.BaseName()))
       info->is_dangerous = true;
     else if (info->is_extension_install &&
              !ExtensionsService::IsDownloadFromGallery(info->url,
                                                        info->referrer_url)) {
       info->is_dangerous = true;
     }
   }
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           this, &DownloadManager::CheckIfSuggestedPathExists, info));
 }
 
 void DownloadManager::CheckIfSuggestedPathExists(DownloadCreateInfo* info) {
   DCHECK(info);
 
   // Check writability of the suggested path. If we can't write to it, default
   // to the user's "My Documents" directory. We'll prompt them in this case.
   FilePath dir = info->suggested_path.DirName();
   FilePath filename = info->suggested_path.BaseName();
   if (!file_util::PathIsWritable(dir)) {
-    info->prompt_user_for_save_location = true;
+    info->save_as = true;
     PathService::Get(chrome::DIR_USER_DOCUMENTS, &info->suggested_path);
     info->suggested_path = info->suggested_path.Append(filename);
   }
 
   // Do not add the path uniquifier if we are saving to a specific path as in
   // the drag-out case.
   if (info->save_info.file_path.empty()) {
     info->path_uniquifier = download_util::GetUniquePathNumber(
         info->suggested_path);
   }
@@ skipping 16 matching lines @@
   } else {
     // We know the final path, build it if necessary.
     if (info->path_uniquifier > 0) {
       download_util::AppendNumberToPath(&(info->suggested_path),
                                         info->path_uniquifier);
       // Setting path_uniquifier to 0 to make sure we don't try to unique it
       // later on.
       info->path_uniquifier = 0;
     } else if (info->path_uniquifier == -1) {
       // We failed to find a unique path.  We have to prompt the user.
-      info->prompt_user_for_save_location = true;
+      info->save_as = true;
     }
   }
 
-  if (!info->prompt_user_for_save_location &&
-      info->save_info.file_path.empty()) {
+  if (!info->save_as && info->save_info.file_path.empty()) {
     // Create an empty file at the suggested path so that we don't allocate the
     // same "non-existant" path to multiple downloads.
     // See: http://code.google.com/p/chromium/issues/detail?id=3662
     file_util::WriteFile(info->suggested_path, "", 0);
   }
 
   // Now we return to the UI thread.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::OnPathExistenceAvailable,
                         info));
 }
 
 void DownloadManager::OnPathExistenceAvailable(DownloadCreateInfo* info) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(info);
 
-  if (info->prompt_user_for_save_location) {
+  if (info->save_as) {
     // We must ask the user for the place to put the download.
     if (!select_file_dialog_.get())
       select_file_dialog_ = SelectFileDialog::Create(this);
 
     TabContents* contents = tab_util::GetTabContentsByID(info->child_id,
                                                          info->render_view_id);
     SelectFileDialog::FileTypeInfo file_type_info;
     file_type_info.extensions.resize(1);
     file_type_info.extensions[0].push_back(info->suggested_path.Extension());
     if (!file_type_info.extensions[0][0].empty())
@@ skipping 26 matching lines @@
                                 info->url,
                                 info->referrer_url,
                                 info->mime_type,
                                 info->original_mime_type,
                                 info->original_name,
                                 info->start_time,
                                 info->total_bytes,
                                 info->child_id,
                                 info->request_id,
                                 info->is_dangerous,
-                                info->prompt_user_for_save_location,
+                                info->save_as,
                                 profile_->IsOffTheRecord(),
                                 info->is_extension_install,
                                 !info->save_info.file_path.empty());
     download->set_manager(this);
     in_progress_[info->download_id] = download;
   } else {
     NOTREACHED();  // Should not exist!
     return;
   }
 
@@ skipping 812 matching lines @@
     if (!extensions.empty())
       extensions.erase(extensions.size() - 1);
 
     prefs->SetString(prefs::kDownloadExtensionsToOpen, extensions);
   }
 }
 
 void DownloadManager::FileSelected(const FilePath& path,
                                    int index, void* params) {
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
-  if (info->prompt_user_for_save_location)
+  if (info->save_as)
     last_download_path_ = path.DirName();
   ContinueStartDownload(info, path);
 }
 
 void DownloadManager::FileSelectionCanceled(void* params) {
   // The user didn't pick a place to save the file, so need to cancel the
   // download that's already in progress to the temporary location.
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
   DownloadCancelledInternal(info->download_id,
                             info->child_id,
@@ skipping 181 matching lines @@
   observing_download_manager_->NotifyModelChanged();
 }
 
 void DownloadManager::OtherDownloadManagerObserver::SetDownloads(
     std::vector<DownloadItem*>& downloads) {
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }