Replace WebUI::tab_contents() with web_contents() and switch all users to use web_contents.h inst...

chrome/browser/ui/webui/chromeos/imageburner/imageburner_utils.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 "chrome/browser/ui/webui/chromeos/imageburner/imageburner_utils.h"
 
 #include "base/bind.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/browser/download/download_types.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
+using content::WebContents;
 
 namespace imageburner {
 
 const char kName[] = "name";
 const char kHwid[] = "hwid";
 const char kFileName[] = "file";
 const char kUrl[] = "url";
 
 const char kConfigFileUrl[] =
     "https://dl.google.com/dl/edgedl/chromeos/recovery/recovery.conf";
@@ skipping 264 matching lines @@
     image_dir_ = image_dir_.Append(kTempImageFolderName);
     success = file_util::CreateDirectory(image_dir_);
   }
   delegate->OnImageDirCreated(success);
 }
 
 const FilePath& BurnManager::GetImageDir() {
   return image_dir_;
 }
 
-void BurnManager::FetchConfigFile(TabContents* tab_contents,
+void BurnManager::FetchConfigFile(WebContents* web_contents,
     Delegate* delegate) {
   if (config_file_fetched_) {
     delegate->OnConfigFileFetched(config_file_, true);
     return;
   }
   downloaders_.push_back(delegate->AsWeakPtr());
 
   if (config_file_requested_)
     return;
   config_file_requested_ = true;
 
   config_file_path_ = GetImageDir().Append(kConfigFileName);
-  download_manager_ = tab_contents->GetBrowserContext()->GetDownloadManager();
+  download_manager_ = web_contents->GetBrowserContext()->GetDownloadManager();
   download_manager_->AddObserver(this);
   downloader()->AddListener(this, config_file_url_);
-  downloader()->DownloadFile(config_file_url_, config_file_path_, tab_contents);
+  downloader()->DownloadFile(config_file_url_, config_file_path_, web_contents);
 }
 
 void BurnManager::ConfigFileFetchedOnUIThread(bool fetched,
     const std::string& content) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (config_file_fetched_)
     return;
 
   if (active_download_item_) {
@@ skipping 26 matching lines @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 class DownloaderTaskProxy
     : public base::RefCountedThreadSafe<DownloaderTaskProxy> {
  public:
   explicit DownloaderTaskProxy() {}
 
   void CreateFileStream(const GURL& url,
                         const FilePath& target_path,
-                        TabContents* tab_contents) {
+                        WebContents* web_contents) {
     BurnManager::GetInstance()->downloader()->
-        CreateFileStreamOnFileThread(url, target_path, tab_contents);
+        CreateFileStreamOnFileThread(url, target_path, web_contents);
   }
 
   void OnFileStreamCreated(const GURL& url,
                            const FilePath& file_path,
-                           TabContents* tab_contents,
+                           WebContents* web_contents,
                            net::FileStream* created_file_stream) {
     BurnManager::GetInstance()->downloader()->
-        OnFileStreamCreatedOnUIThread(url, file_path, tab_contents,
+        OnFileStreamCreatedOnUIThread(url, file_path, web_contents,
         created_file_stream);
   }
 
  private:
   ~DownloaderTaskProxy() {}
 
   friend class base::RefCountedThreadSafe<DownloaderTaskProxy>;
 
   DISALLOW_COPY_AND_ASSIGN(DownloaderTaskProxy);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Downloader
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 Downloader::Downloader() {}
 
 Downloader::~Downloader() {}
 
 void Downloader::DownloadFile(const GURL& url,
-    const FilePath& file_path, TabContents* tab_contents) {
+    const FilePath& file_path, WebContents* web_contents) {
   // First we have to create file stream we will download file to.
   // That has to be done on File thread.
   scoped_refptr<DownloaderTaskProxy> task = new DownloaderTaskProxy();
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloaderTaskProxy::CreateFileStream, task.get(), url,
-                 file_path, tab_contents));
+                 file_path, web_contents));
 }
 
 void Downloader::CreateFileStreamOnFileThread(
     const GURL& url, const FilePath& file_path,
-    TabContents* tab_contents) {
+    WebContents* web_contents) {
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(!file_path.empty());
 
   scoped_ptr<net::FileStream> file_stream(new net::FileStream);
   // TODO(tbarzic): Save temp image file to temp folder instead of Downloads
   // once extracting image directly to removalbe device is implemented
   if (file_stream->Open(file_path, base::PLATFORM_FILE_OPEN_ALWAYS |
                         base::PLATFORM_FILE_WRITE))
     file_stream.reset(NULL);
 
   scoped_refptr<DownloaderTaskProxy> task = new DownloaderTaskProxy();
   // Call callback method on UI thread.
   BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloaderTaskProxy::OnFileStreamCreated, task.get(),
-                   url, file_path, tab_contents, file_stream.release()));
+                   url, file_path, web_contents, file_stream.release()));
 }
 
 void Downloader::OnFileStreamCreatedOnUIThread(const GURL& url,
-    const FilePath& file_path, TabContents* tab_contents,
+    const FilePath& file_path, WebContents* web_contents,
     net::FileStream* created_file_stream) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (created_file_stream) {
     DownloadManager* download_manager =
-        tab_contents->GetBrowserContext()->GetDownloadManager();
+        web_contents->GetBrowserContext()->GetDownloadManager();
     DownloadSaveInfo save_info;
     save_info.file_path = file_path;
     save_info.file_stream = linked_ptr<net::FileStream>(created_file_stream);
     DownloadStarted(true, url);
-    download_manager->DownloadUrlToFile(url,
-                                        tab_contents->GetURL(),
-                                        tab_contents->GetEncoding(),
-                                        save_info,
-                                        tab_contents);
+    download_manager->DownloadUrlToFile(
+        url,
+        web_contents->GetURL(),
+        web_contents->GetEncoding(),
+        save_info,
+        static_cast<TabContents*>(web_contents));
   } else {
     DownloadStarted(false, url);
   }
 }
 
 void Downloader::AddListener(Listener* listener, const GURL& url) {
   listeners_.insert(std::make_pair(url, listener->AsWeakPtr()));
 }
 
 void Downloader::DownloadStarted(bool success, const GURL& url) {
   std::pair<ListenerMap::iterator, ListenerMap::iterator> listener_range =
       listeners_.equal_range(url);
   for (ListenerMap::iterator current_listener = listener_range.first;
        current_listener != listener_range.second;
        ++current_listener) {
     if (current_listener->second)
       current_listener->second->OnBurnDownloadStarted(success);
   }
   listeners_.erase(listener_range.first, listener_range.second);
 }
 
 }  // namespace imageburner