Extensions: Use OnceCallbacks in FileReader.

The callbacks in FileReader are used as once callbacks, but they
are declared to be RepeatingCallbacks. Fix this.

Bug: 812717
Change-Id: I89badc6bbd3583fc510d47218bb7bb69d537964a
Reviewed-on: https://chromium-review.googlesource.com/919704Reviewed-by: Karan Bhatia <karandeepb@chromium.org>
Commit-Queue: Istiaque Ahmed <lazyboy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#537392}

extensions/browser/api/execute_code_function.cc

@@ -251,14 +251,15 @@ bool ExecuteCodeFunction::LoadFile(const std::string& file) {
                        true /* We assume this call always succeeds */));
   } else {
     FileReader::OptionalFileSequenceTask get_file_and_l10n_callback =
-        base::Bind(&ExecuteCodeFunction::GetFileURLAndMaybeLocalizeInBackground,
-                   this, extension_id, extension_path, extension_default_locale,
-                   might_require_localization);
-
-    scoped_refptr<FileReader> file_reader(new FileReader(
-        resource_, get_file_and_l10n_callback,
-        base::Bind(&ExecuteCodeFunction::DidLoadAndLocalizeFile, this,
-                   resource_.relative_path().AsUTF8Unsafe())));
+        base::BindOnce(
+            &ExecuteCodeFunction::GetFileURLAndMaybeLocalizeInBackground, this,
+            extension_id, extension_path, extension_default_locale,
+            might_require_localization);
+
+    auto file_reader = base::MakeRefCounted<FileReader>(
+        resource_, std::move(get_file_and_l10n_callback),
+        base::BindOnce(&ExecuteCodeFunction::DidLoadAndLocalizeFile, this,
+                       resource_.relative_path().AsUTF8Unsafe()));
     file_reader->Start();
   }
 

extensions/browser/file_reader.cc

@@ -10,13 +10,12 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "extensions/browser/extension_file_task_runner.h"
 
-FileReader::FileReader(
-    const extensions::ExtensionResource& resource,
-    const OptionalFileSequenceTask& optional_file_sequence_task,
-    const DoneCallback& done_callback)
+FileReader::FileReader(const extensions::ExtensionResource& resource,
+                       OptionalFileSequenceTask optional_file_sequence_task,
+                       DoneCallback done_callback)
     : resource_(resource),
-      optional_file_sequence_task_(optional_file_sequence_task),
-      done_callback_(done_callback),
+      optional_file_sequence_task_(std::move(optional_file_sequence_task)),
+      done_callback_(std::move(done_callback)),
       origin_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
 void FileReader::Start() {
@@ -33,15 +32,14 @@ void FileReader::ReadFileOnFileSequence() {
   std::unique_ptr<std::string> data(new std::string());
   bool success = base::ReadFileToString(resource_.GetFilePath(), data.get());
 
-  if (!optional_file_sequence_task_.is_null()) {
-    if (success) {
-      base::ResetAndReturn(&optional_file_sequence_task_).Run(data.get());
-    } else {
+  if (optional_file_sequence_task_) {
+    if (success)
+      std::move(optional_file_sequence_task_).Run(data.get());
+    else
       optional_file_sequence_task_.Reset();
-    }
   }
 
   origin_task_runner_->PostTask(
-      FROM_HERE, base::Bind(base::ResetAndReturn(&done_callback_), success,
-                            base::Passed(std::move(data))));
+      FROM_HERE,
+      base::BindOnce(std::move(done_callback_), success, std::move(data)));
 }

extensions/browser/file_reader.h

@@ -18,17 +18,17 @@
 // back to chrome/browser/net if other subsystems want to use it.
 class FileReader : public base::RefCountedThreadSafe<FileReader> {
  public:
-  // TODO(devlin): Use base::OnceCallback here.
   // Reports success or failure and the data of the file upon success.
-  using DoneCallback = base::Callback<void(bool, std::unique_ptr<std::string>)>;
+  using DoneCallback =
+      base::OnceCallback<void(bool, std::unique_ptr<std::string>)>;
   // Lets the caller accomplish tasks on the file data, after the file content
   // has been read.
   // If the file reading doesn't succeed, this will be ignored.
-  using OptionalFileSequenceTask = base::Callback<void(std::string*)>;
+  using OptionalFileSequenceTask = base::OnceCallback<void(std::string*)>;
 
   FileReader(const extensions::ExtensionResource& resource,
-             const OptionalFileSequenceTask& file_sequence_task,
-             const DoneCallback& done_callback);
+             OptionalFileSequenceTask file_sequence_task,
+             DoneCallback done_callback);
 
   // Called to start reading the file on a background sequence. Upon completion,
   // the callback will be notified of the results.