Move most of the remaining users of WebContentsObserver::tab_contents() to use web_contents().

content/browser/download/save_package.cc

 // Copyright (c) 2011 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/save_package.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 206 matching lines @@
   file_manager_ = NULL;
 }
 
 GURL SavePackage::GetUrlToBeSaved() {
   // Instead of using tab_contents_.GetURL here, we use url()
   // (which is the "real" url of the page)
   // from the NavigationEntry because it reflects its' origin
   // rather than the displayed one (returned by GetURL) which may be
   // different (like having "view-source:" on the front).
   NavigationEntry* active_entry =
-      tab_contents()->GetController().GetActiveEntry();
+      web_contents()->GetController().GetActiveEntry();
   return active_entry->GetURL();
 }
 
 void SavePackage::Cancel(bool user_action) {
   if (!canceled()) {
     if (user_action)
       user_canceled_ = true;
     else
       disk_error_occurred_ = true;
     Stop();
   }
 }
 
 // Init() can be called directly, or indirectly via GetSaveInfo(). In both
 // cases, we need file_manager_ to be initialized, so we do this first.
 void SavePackage::InternalInit() {
   ResourceDispatcherHost* rdh =
       content::GetContentClient()->browser()->GetResourceDispatcherHost();
   if (!rdh) {
     NOTREACHED();
     return;
   }
 
   file_manager_ = rdh->save_file_manager();
   DCHECK(file_manager_);
 
-  download_manager_ = tab_contents()->GetBrowserContext()->GetDownloadManager();
+  download_manager_ = web_contents()->GetBrowserContext()->GetDownloadManager();
   DCHECK(download_manager_);
 }
 
 bool SavePackage::Init() {
   // Set proper running state.
   if (wait_state_ != INITIALIZE)
     return false;
 
   wait_state_ = START_PROCESS;
 
   // Initialize the request context and resource dispatcher.
   content::BrowserContext* browser_context =
-      tab_contents()->GetBrowserContext();
+      web_contents()->GetBrowserContext();
   if (!browser_context) {
     NOTREACHED();
     return false;
   }
 
   // The download manager keeps ownership but adds us as an observer.
   download_ = download_manager_->CreateSavePackageDownloadItem(
       saved_main_file_path_, page_url_,
       browser_context->IsOffTheRecord(), this);
 
@@ skipping 367 matching lines @@
       it != saved_success_items_.end(); ++it)
     final_names.push_back(std::make_pair(it->first,
                                          it->second->full_path()));
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SaveFileManager::RenameAllFiles,
                  file_manager_,
                  final_names,
                  dir,
-                 tab_contents()->GetRenderProcessHost()->GetID(),
-                 tab_contents()->GetRenderViewHost()->routing_id(),
+                 web_contents()->GetRenderProcessHost()->GetID(),
+                 web_contents()->GetRenderViewHost()->routing_id(),
                  id()));
 }
 
 // Successfully finished all items of this SavePackage.
 void SavePackage::Finish() {
   // User may cancel the job when we're moving files to the final directory.
   if (canceled())
     return;
 
   wait_state_ = SUCCESSFUL;
@@ skipping 110 matching lines @@
         base::Bind(&SaveFileManager::CancelSave,
                    file_manager_,
                    save_item->save_id()));
 }
 
 // Initiate a saving job of a specific URL. We send the request to
 // SaveFileManager, which will dispatch it to different approach according to
 // the save source. Parameter process_all_remaining_items indicates whether
 // we need to save all remaining items.
 void SavePackage::SaveNextFile(bool process_all_remaining_items) {
-  DCHECK(tab_contents());
+  DCHECK(web_contents());
   DCHECK(waiting_item_queue_.size());
 
   do {
     // Pop SaveItem from waiting list.
     SaveItem* save_item = waiting_item_queue_.front();
     waiting_item_queue_.pop();
 
     // Add the item to in_progress_items_.
     SaveUrlItemMap::iterator it = in_progress_items_.find(
         save_item->url().spec());
     DCHECK(it == in_progress_items_.end());
     in_progress_items_[save_item->url().spec()] = save_item;
     save_item->Start();
     file_manager_->SaveURL(save_item->url(),
                            save_item->referrer(),
-                           tab_contents()->GetRenderProcessHost()->GetID(),
+                           web_contents()->GetRenderProcessHost()->GetID(),
                            routing_id(),
                            save_item->save_source(),
                            save_item->full_path(),
-                           tab_contents()->
+                           web_contents()->
                                GetBrowserContext()->GetResourceContext(),
                            this);
   } while (process_all_remaining_items && waiting_item_queue_.size());
 }
 
 // Calculate the percentage of whole save page job.
 int SavePackage::PercentComplete() {
   if (!all_save_items_count_)
     return 0;
   else if (!in_process_count())
@@ skipping 337 matching lines @@
       static_cast<TabContents*>(content::WebContentsObserver::web_contents());
 }
 
 void SavePackage::GetSaveInfo() {
   // Can't use tab_contents_ in the file thread, so get the data that we need
   // before calling to it.
   FilePath website_save_dir, download_save_dir;
   DCHECK(download_manager_);
   download_manager_->delegate()->GetSaveDir(
       tab_contents(), &website_save_dir, &download_save_dir);
-  std::string mime_type = tab_contents()->GetContentsMimeType();
+  std::string mime_type = web_contents()->GetContentsMimeType();
   std::string accept_languages =
       content::GetContentClient()->browser()->GetAcceptLangs(
-          tab_contents()->GetBrowserContext());
+          web_contents()->GetBrowserContext());
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SavePackage::CreateDirectoryOnFileThread, this,
           website_save_dir, download_save_dir, mime_type, accept_languages));
 }
 
 void SavePackage::CreateDirectoryOnFileThread(
     const FilePath& website_save_dir,
     const FilePath& download_save_dir,
@@ skipping 37 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&SavePackage::ContinueGetSaveInfo, this, save_dir,
                  can_save_as_complete));
 }
 
 void SavePackage::ContinueGetSaveInfo(const FilePath& suggested_path,
                                       bool can_save_as_complete) {
   // The TabContents which owns this SavePackage may have disappeared during
   // the UI->FILE->UI thread hop of
   // GetSaveInfo->CreateDirectoryOnFileThread->ContinueGetSaveInfo.
-  if (!tab_contents())
+  if (!web_contents())
     return;
 
   download_manager_->delegate()->ChooseSavePath(
       AsWeakPtr(), suggested_path, can_save_as_complete);
 }
 
 // Called after the save file dialog box returns.
 void SavePackage::OnPathPicked(const FilePath& final_name,
                                SavePackageType type) {
   // Ensure the filename is safe.
   saved_main_file_path_ = final_name;
   // TODO(asanka): This call may block on IO and shouldn't be made
   // from the UI thread.  See http://crbug.com/61827.
-  net::GenerateSafeFileName(tab_contents()->GetContentsMimeType(), false,
+  net::GenerateSafeFileName(web_contents()->GetContentsMimeType(), false,
                             &saved_main_file_path_);
 
   saved_main_directory_path_ = saved_main_file_path_.DirName();
   save_type_ = type;
   if (save_type_ == SavePackage::SAVE_AS_COMPLETE_HTML) {
     // Make new directory for saving complete file.
     saved_main_directory_path_ = saved_main_directory_path_.Append(
         saved_main_file_path_.RemoveExtension().BaseName().value() +
         FILE_PATH_LITERAL("_files"));
   }
@@ skipping 42 matching lines @@
     StopObservation();
 }
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_manager_->SavePageDownloadFinished(download_);
   StopObservation();
 }