Save Page As MHTML

chrome/browser/download/chrome_download_manager_delegate.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 "chrome/browser/download/chrome_download_manager_delegate.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 136 matching lines @@
   CheckDownloadUrlDone(download_id, DownloadProtectionService::SAFE);
   return false;
 }
 
 void ChromeDownloadManagerDelegate::ChooseDownloadPath(
     WebContents* web_contents,
     const FilePath& suggested_path,
     int32 download_id) {
   // Deletes itself.
 #if defined(OS_CHROMEOS)
-  new DownloadFilePickerChromeOS(
+  new DownloadFilePickerChromeOS
 #else
-  new DownloadFilePicker(
+  new DownloadFilePicker
 #endif
-      download_manager_, web_contents, suggested_path, download_id);
+      (download_manager_, web_contents, suggested_path, download_id);
 }
 
 FilePath ChromeDownloadManagerDelegate::GetIntermediatePath(
     const FilePath& suggested_path) {
   return download_util::GetCrDownloadPath(suggested_path);
 }
 
 WebContents* ChromeDownloadManagerDelegate::
     GetAlternativeWebContentsToNotifyForDownload() {
 #if defined(OS_ANDROID)
@@ skipping 14 matching lines @@
   FilePath::StringType extension = path.Extension();
   if (extension.empty())
     return false;
   if (Extension::IsExtension(path))
     return false;
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
   return download_prefs_->IsAutoOpenEnabledForExtension(extension);
 }
 
+// static
+void ChromeDownloadManagerDelegate::DisableSafeBrowsing(DownloadItem* item) {
+#if defined(ENABLE_SAFE_BROWSING)
+  SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
+      item->GetExternalData(&safe_browsing_id));
+  if (state == NULL) {
+    state = new SafeBrowsingState();
+    item->SetExternalData(&safe_browsing_id, state);
+  }
+  state->pending = false;

[asanka, 2012/05/02 19:26:10]

Shouldn't this only be done if state == NULL?

Ideally, I think you should DCHECK that state == NULL if someone is trying to
disable safe browsing.

[benjhayden, 2012/05/03 16:56:48]

Done.

+  state->verdict = DownloadProtectionService::SAFE;
+#endif
+}
+
 bool ChromeDownloadManagerDelegate::ShouldCompleteDownload(DownloadItem* item) {
 #if defined(ENABLE_SAFE_BROWSING)
   // See if there is already a pending SafeBrowsing check for that download.
   SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
       item->GetExternalData(&safe_browsing_id));
-  if (state)
-    // Don't complete the download until we have an answer.
-    return !state->pending;
+  // Don't complete the download until we have an answer.
+  if (state && state->pending)
+    return false;
 
-  // Begin the safe browsing download protection check.
-  DownloadProtectionService* service = GetDownloadProtectionService();
-  if (service) {
-    VLOG(2) << __FUNCTION__ << "() Start SB download check for download = "
-            << item->DebugString(false);
-    state = new SafeBrowsingState();
-    state->pending = true;
-    state->verdict = DownloadProtectionService::SAFE;
-    item->SetExternalData(&safe_browsing_id, state);
-    service->CheckClientDownload(
-        DownloadProtectionService::DownloadInfo::FromDownloadItem(*item),
-        base::Bind(
-            &ChromeDownloadManagerDelegate::CheckClientDownloadDone,
-            this,
-            item->GetId()));
-    return false;
+  if (state == NULL) {
+    // Begin the safe browsing download protection check.
+    DownloadProtectionService* service = GetDownloadProtectionService();
+    if (service) {
+      VLOG(2) << __FUNCTION__ << "() Start SB download check for download = "
+              << item->DebugString(false);
+      state = new SafeBrowsingState();
+      state->pending = true;
+      state->verdict = DownloadProtectionService::SAFE;
+      item->SetExternalData(&safe_browsing_id, state);
+      service->CheckClientDownload(
+          DownloadProtectionService::DownloadInfo::FromDownloadItem(*item),
+          base::Bind(
+              &ChromeDownloadManagerDelegate::CheckClientDownloadDone,
+              this,
+              item->GetId()));
+      return false;
+    }
   }
 #endif
+
 #if defined(OS_CHROMEOS)
   // If there's a GData upload associated with this download, we wait until that
   // is complete before allowing the download item to complete.
   if (!gdata::GDataDownloadObserver::IsReadyToComplete(item))
     return false;
 #endif
   return true;
 }
 
 bool ChromeDownloadManagerDelegate::ShouldOpenDownload(DownloadItem* item) {
@@ skipping 135 matching lines @@
   DCHECK(!website_save_dir->empty());
 
   *download_save_dir = prefs->GetFilePath(prefs::kDownloadDefaultDirectory);
 }
 
 void ChromeDownloadManagerDelegate::ChooseSavePath(
     WebContents* web_contents,
     const FilePath& suggested_path,
     const FilePath::StringType& default_extension,
     bool can_save_as_complete,
-    content::SaveFilePathPickedCallback callback) {
+    const content::SavePackagePathPickedCallback& callback) {
   // Deletes itself.
 #if defined(OS_CHROMEOS)
-  // Note that we're ignoring the callback here.
-  // SavePackageFilePickerChromeOS completes the save operation itself.
-  // TODO(achuith): Fix this.
-  new SavePackageFilePickerChromeOS(web_contents, suggested_path);
+  new SavePackageFilePickerChromeOS(web_contents, suggested_path, callback);
 #else
   new SavePackageFilePicker(web_contents, suggested_path, default_extension,
       can_save_as_complete, download_prefs_.get(), callback);
 #endif
 }
 
 #if defined(ENABLE_SAFE_BROWSING)
 DownloadProtectionService*
     ChromeDownloadManagerDelegate::GetDownloadProtectionService() {
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
@@ skipping 305 matching lines @@
     int32 download_id, int64 db_handle) {
   // It's not immediately obvious, but HistoryBackend::CreateDownload() can
   // call this function with an invalid |db_handle|. For instance, this can
   // happen when the history database is offline. We cannot have multiple
   // DownloadItems with the same invalid db_handle, so we need to assign a
   // unique |db_handle| here.
   if (db_handle == DownloadItem::kUninitializedHandle)
     db_handle = download_history_->GetNextFakeDbHandle();
   download_manager_->OnItemAddedToPersistentStore(download_id, db_handle);
 }