base::Bind conversion for chrome/browser/extensions/file_reader.

chrome/browser/extensions/execute_code_in_tab_function.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/extensions/execute_code_in_tab_function.h"
 
+#include "base/bind.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/browser/extensions/file_reader.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
@@ skipping 94 matching lines @@
     if (!script_info->GetString(keys::kFileKey, &relative_path))
       return false;
     resource_ = GetExtension()->GetResource(relative_path);
   }
   if (resource_.extension_root().empty() || resource_.relative_path().empty()) {
     error_ = keys::kNoCodeOrFileToExecuteError;
     return false;
   }
 
   scoped_refptr<FileReader> file_reader(new FileReader(
-      resource_, NewCallback(this, &ExecuteCodeInTabFunction::DidLoadFile)));
+      resource_, base::Bind(&ExecuteCodeInTabFunction::DidLoadFile, this)));
   file_reader->Start();
-  AddRef();  // Keep us alive until DidLoadAndLocalizeFile is called.
 
   return true;
 }
 
 void ExecuteCodeInTabFunction::DidLoadFile(bool success,
                                            const std::string& data) {
   std::string function_name = name();
   const Extension* extension = GetExtension();
 
   // Check if the file is CSS and needs localization.
   if (success &&
       function_name == TabsInsertCSSFunction::function_name() &&
       extension != NULL &&
       data.find(ExtensionMessageBundle::kMessageBegin) != std::string::npos) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(this, &ExecuteCodeInTabFunction::LocalizeCSS,
-                          data,
-                          extension->id(),
-                          extension->path(),
-                          extension->default_locale()));
+        base::Bind(&ExecuteCodeInTabFunction::LocalizeCSS, this,
+                   data,
+                   extension->id(),
+                   extension->path(),
+                   extension->default_locale()));
   } else {
     DidLoadAndLocalizeFile(success, data);
   }
 }
 
 void ExecuteCodeInTabFunction::LocalizeCSS(
     const std::string& data,
     const std::string& extension_id,
     const FilePath& extension_path,
     const std::string& extension_default_locale) {
   scoped_ptr<SubstitutionMap> localization_messages(
       extension_file_util::LoadExtensionMessageBundleSubstitutionMap(
           extension_path, extension_id, extension_default_locale));
 
   // We need to do message replacement on the data, so it has to be mutable.
   std::string css_data = data;
   std::string error;
   ExtensionMessageBundle::ReplaceMessagesWithExternalDictionary(
       *localization_messages, &css_data, &error);
 
   // Call back DidLoadAndLocalizeFile on the UI thread. The success parameter
   // is always true, because if loading had failed, we wouldn't have had
   // anything to localize.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(this,
-                        &ExecuteCodeInTabFunction::DidLoadAndLocalizeFile,
-                        true, css_data));
+      base::Bind(&ExecuteCodeInTabFunction::DidLoadAndLocalizeFile, this,
+                 true, css_data));
 }
 
 void ExecuteCodeInTabFunction::DidLoadAndLocalizeFile(bool success,
                                                       const std::string& data) {
   if (success) {
     Execute(data);
   } else {
 #if defined(OS_POSIX)
     // TODO(viettrungluu): bug: there's no particular reason the path should be
     // UTF-8, in which case this may fail.
     error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kLoadFileError,
         resource_.relative_path().value());
 #elif defined(OS_WIN)
     error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kLoadFileError,
         WideToUTF8(resource_.relative_path().value()));
 #endif  // OS_WIN
     SendResponse(false);
   }
-  Release();  // Balance the AddRef taken in RunImpl
 }
 
 bool ExecuteCodeInTabFunction::Execute(const std::string& code_string) {
   TabContentsWrapper* contents = NULL;
   Browser* browser = NULL;
 
   bool success = ExtensionTabUtil::GetTabById(
       execute_tab_id_, profile(), include_incognito(), &browser, NULL,
       &contents, NULL) && contents && browser;
 
@@ skipping 58 matching lines @@
   if (!error.empty()) {
     CHECK(!success);
     error_ = error;
   }
 
   SendResponse(success);
 
   Observe(NULL);
   Release();  // balanced in Execute()
 }