Use URLFetcher to download ChromeOS recovery image config file

chrome/browser/chromeos/imageburner/burn_manager.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/chromeos/imageburner/burn_manager.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_util.h"
-#include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/browser/download/download_types.h"
-#include "content/browser/renderer_host/render_view_host.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/download_manager.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/url_fetcher.h"
+#include "net/base/file_stream.h"
+#include "net/url_request/url_request_status.h"
 
 using content::BrowserThread;
-using content::DownloadItem;
 using content::DownloadManager;
 using content::WebContents;
 
 namespace chromeos {
 namespace imageburner {
 
 namespace {
 
 const char kConfigFileUrl[] =
     "https://dl.google.com/dl/edgedl/chromeos/recovery/recovery.conf";
 const char kTempImageFolderName[] = "chromeos_image";
-const char kConfigFileName[] = "recovery.conf";
 
 BurnManager* g_burn_manager = NULL;
 
 // Cretes a directory and calls |callback| with the result on UI thread.
 void CreateDirectory(const FilePath& path,
                      base::Callback<void(bool success)> callback) {
   const bool success = file_util::CreateDirectory(path);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, success));
 }
 
-// Reads file content and calls |callback| with the result on UI thread.
-void ReadFile(const FilePath& path,
-              base::Callback<void(bool success,
-                                  const std::string& file_content)> callback) {
-  std::string file_content;
-  const bool success = file_util::ReadFileToString(path, &file_content);
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(callback, success, file_content));
-}
-
 // Creates a FileStream and calls |callback| with the result on UI thread.
 void CreateFileStream(
     const FilePath& file_path,
     base::Callback<void(net::FileStream* file_stream)> callback) {
   scoped_ptr<net::FileStream> file_stream(new net::FileStream(NULL));
   // TODO(tbarzic): Save temp image file to temp folder instead of Downloads
   // once extracting image directly to removalbe device is implemented
   if (file_stream->OpenSync(file_path, base::PLATFORM_FILE_OPEN_ALWAYS |
                             base::PLATFORM_FILE_WRITE))
     file_stream.reset();
@@ skipping 156 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // BurnManager
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 BurnManager::BurnManager()
     : weak_ptr_factory_(this),
-      download_manager_(NULL),
-      download_item_observer_added_(false),
-      active_download_item_(NULL),
       config_file_url_(kConfigFileUrl),
-      config_file_requested_(false),
-      config_file_fetched_(false),
       state_machine_(new StateMachine()),
       downloader_(NULL) {
 }
 
 BurnManager::~BurnManager() {
   if (!image_dir_.empty()) {
     file_util::Delete(image_dir_, true);
   }
-  if (active_download_item_)
-    active_download_item_->RemoveObserver(this);
-  if (download_manager_)
-    download_manager_->RemoveObserver(this);
 }
 
 // static
 void BurnManager::Initialize() {
   if (g_burn_manager) {
     LOG(WARNING) << "BurnManager was already initialized";
     return;
   }
   g_burn_manager = new BurnManager();
   VLOG(1) << "BurnManager initialized";
 }
 
 // static
 void BurnManager::Shutdown() {
   if (!g_burn_manager) {
     LOG(WARNING) << "BurnManager::Shutdown() called with NULL manager";
     return;
   }
   delete g_burn_manager;
   g_burn_manager = NULL;
   VLOG(1) << "BurnManager Shutdown completed";
 }
 
 // static
 BurnManager* BurnManager::GetInstance() {
   return g_burn_manager;
 }
 
-void BurnManager::OnDownloadUpdated(DownloadItem* download) {
-  if (download->IsCancelled()) {
-    ConfigFileFetched(false, "");
-    DCHECK(!download_item_observer_added_);
-    DCHECK(active_download_item_ == NULL);
-  } else if (download->IsComplete()) {
-    OnConfigFileDownloaded();
-  }
-}
-
-void BurnManager::OnConfigFileDownloaded() {
-  BrowserThread::PostBlockingPoolTask(
-      FROM_HERE,
-      base::Bind(ReadFile,
-                 config_file_path_,
-                 base::Bind(&BurnManager::ConfigFileFetched,
-                            weak_ptr_factory_.GetWeakPtr())));
-}
-
-void BurnManager::ModelChanged(DownloadManager* manager) {
-  DCHECK_EQ(download_manager_, manager);
-
-  std::vector<DownloadItem*> downloads;
-  download_manager_->GetTemporaryDownloads(GetImageDir(), &downloads);
-  if (download_item_observer_added_)
-    return;
-  for (std::vector<DownloadItem*>::const_iterator it = downloads.begin();
-      it != downloads.end();
-      ++it) {
-    if ((*it)->GetURL() == config_file_url_) {
-      download_item_observer_added_ = true;
-      (*it)->AddObserver(this);
-      active_download_item_ = *it;
-      break;
-    }
-  }
-}
-
-void BurnManager::OnBurnDownloadStarted(bool success) {
-  if (!success)
-    ConfigFileFetched(false, "");
-}
-
 void BurnManager::CreateImageDir(Delegate* delegate) {
   if (image_dir_.empty()) {
     CHECK(PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &image_dir_));
     image_dir_ = image_dir_.Append(kTempImageFolderName);
     BrowserThread::PostBlockingPoolTask(
         FROM_HERE,
         base::Bind(CreateDirectory,
                    image_dir_,
                    base::Bind(&BurnManager::OnImageDirCreated,
                               weak_ptr_factory_.GetWeakPtr(),
                               delegate)));
   } else {
     const bool success = true;
     OnImageDirCreated(delegate, success);
   }
 }
 
 void BurnManager::OnImageDirCreated(Delegate* delegate, bool success) {
   delegate->OnImageDirCreated(success);
 }
 
 const FilePath& BurnManager::GetImageDir() {
   return image_dir_;
 }
 
-void BurnManager::FetchConfigFile(WebContents* web_contents,
-                                  Delegate* delegate) {
-  if (config_file_fetched_) {
+void BurnManager::FetchConfigFile(Delegate* delegate) {
+  if (config_file_fetched()) {
     delegate->OnConfigFileFetched(config_file_, true);
     return;
   }
   downloaders_.push_back(delegate->AsWeakPtr());
 
-  if (config_file_requested_)
+  if (config_fetcher_.get())
     return;
-  config_file_requested_ = true;
 
-  config_file_path_ = GetImageDir().Append(kConfigFileName);
-  download_manager_ = web_contents->GetBrowserContext()->GetDownloadManager();
-  download_manager_->AddObserver(this);
-  downloader()->AddListener(this, config_file_url_);
-  downloader()->DownloadFile(config_file_url_, config_file_path_, web_contents);
+  config_fetcher_.reset(content::URLFetcher::Create(
+      config_file_url_, content::URLFetcher::GET, this));
+  config_fetcher_->StartWithRequestContextGetter(
+      g_browser_process->system_request_context());
+}
+
+void BurnManager::OnURLFetchComplete(const content::URLFetcher* source) {
+  if (source == config_fetcher_.get()) {
+    std::string data;
+    const bool success =
+        source->GetStatus().status() == net::URLRequestStatus::SUCCESS;
+    if (success)
+      config_fetcher_->GetResponseAsString(&data);
+    config_fetcher_.reset();
+    ConfigFileFetched(success, data);
+  }
 }
 
 void BurnManager::ConfigFileFetched(bool fetched, const std::string& content) {
-  if (config_file_fetched_)
+  if (config_file_fetched())
     return;
 
-  if (active_download_item_) {
-    active_download_item_->RemoveObserver(this);
-    active_download_item_ = NULL;
-  }
-  download_item_observer_added_ = false;
-  if (download_manager_)
-    download_manager_->RemoveObserver(this);
-
-  config_file_fetched_ = fetched;
-
   if (fetched) {
     config_file_.reset(content);
   } else {
     config_file_.clear();
   }
 
   for (size_t i = 0; i < downloaders_.size(); ++i) {
     if (downloaders_[i]) {
       downloaders_[i]->OnConfigFileFetched(config_file_, fetched);
     }
@@ skipping 62 matching lines @@
        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
 }  // namespace chromeos