Revert 118659 - Some cleanup

chrome/browser/chromeos/cros/burn_library.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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/chromeos/cros/burn_library.h"
 
+#include <cstring>
+
 #include "base/bind.h"
-#include "base/observer_list.h"
+#include "base/memory/linked_ptr.h"
 #include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
 #include "chrome/browser/chromeos/dbus/image_burner_client.h"
 #include "chrome/browser/chromeos/disks/disk_mount_manager.h"
 #include "chrome/common/zip.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
-// Unzips |source_zip_file| and calls |callback| with the filename of
-// the unzipped image.
 void UnzipImage(
     const FilePath& source_zip_file,
     const std::string& image_name,
     base::Callback<void(const std::string& source_image_file)> callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::string source_image_file;
   if (zip::Unzip(source_zip_file, source_zip_file.DirName())) {
     source_image_file =
         source_zip_file.DirName().Append(image_name).value();
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(callback, source_image_file));
 }
 
+}  // namespace
+
 class BurnLibraryImpl : public BurnLibrary {
  public:
   BurnLibraryImpl();
   virtual ~BurnLibraryImpl();
 
   // BurnLibrary implementation.
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual void DoBurn(const FilePath& source_path,
                       const std::string& image_name,
@@ skipping 145 matching lines @@
   BurnLibraryImpl* self = static_cast<BurnLibraryImpl*>(object);
   if (success) {
     self->BurnImage();
   } else {
     self->UpdateBurnStatus(ImageBurnStatus(0, 0), BURN_FAIL);
   }
 }
 
 void BurnLibraryImpl::BurnImage() {
   DBusThreadManager::Get()->GetImageBurnerClient()->BurnImage(
-      source_image_file_,
-      target_file_path_,
+      source_image_file_.c_str(),
+      target_file_path_.c_str(),
       base::Bind(&BurnLibraryImpl::OnBurnImageFail,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BurnLibraryImpl::UpdateBurnStatus(const ImageBurnStatus& status,
                                        BurnEvent evt) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (cancelled_)
     return;
@@ skipping 25 matching lines @@
   virtual void DoBurn(const FilePath& source_path,
                       const std::string& image_name,
                       const FilePath& target_file_path,
                       const FilePath& target_device_path) OVERRIDE {
   }
   virtual void CancelBurnImage() OVERRIDE {}
 
   DISALLOW_COPY_AND_ASSIGN(BurnLibraryStubImpl);
 };
 
-}  // namespace
-
 // static
 BurnLibrary* BurnLibrary::GetImpl(bool stub) {
   BurnLibrary* impl;
   if (stub)
     impl = new BurnLibraryStubImpl();
   else
     impl = new BurnLibraryImpl();
   impl->Init();
   return impl;
 }
 
 }  // namespace chromeos