Move API functions registrations out of ExtensionFunctionRegistry.

chrome/browser/chromeos/extensions/wallpaper_private_api.cc

 // Copyright (c) 2013 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/extensions/wallpaper_private_api.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/wm/window_cycle_controller.h"
@@ skipping 156 matching lines @@
     DCHECK(i != windows_.end());
     windows_.erase(i);
   }
 
   // List of minimized windows.
   std::vector<aura::Window*> windows_;
 };
 
 }  // namespace
 
-bool WallpaperStringsFunction::RunImpl() {
+bool WallpaperPrivateGetStringsFunction::RunImpl() {
   DictionaryValue* dict = new DictionaryValue();
   SetResult(dict);
 
 #define SET_STRING(id, idr) \
   dict->SetString(id, l10n_util::GetStringUTF16(idr))
   SET_STRING("webFontFamily", IDS_WEB_FONT_FAMILY);
   SET_STRING("webFontSize", IDS_WEB_FONT_SIZE);
   SET_STRING("searchTextLabel", IDS_WALLPAPER_MANAGER_SEARCH_TEXT_LABEL);
   SET_STRING("authorLabel", IDS_WALLPAPER_MANAGER_AUTHOR_LABEL);
   SET_STRING("customCategoryLabel",
@@ skipping 100 matching lines @@
   wallpaper_decoder_->Start(data);
 }
 
 void WallpaperFunctionBase::OnFailureOrCancel(const std::string& error) {
   wallpaper_decoder_ = NULL;
   if (!error.empty())
     SetError(error);
   SendResponse(false);
 }
 
-WallpaperSetWallpaperIfExistFunction::WallpaperSetWallpaperIfExistFunction() {
-}
+WallpaperPrivateSetWallpaperIfExistFunction::
+    WallpaperPrivateSetWallpaperIfExistFunction() {}
 
-WallpaperSetWallpaperIfExistFunction::~WallpaperSetWallpaperIfExistFunction() {
-}
+WallpaperPrivateSetWallpaperIfExistFunction::
+    ~WallpaperPrivateSetWallpaperIfExistFunction() {}
 
-bool WallpaperSetWallpaperIfExistFunction::RunImpl() {
+bool WallpaperPrivateSetWallpaperIfExistFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url_));
   EXTENSION_FUNCTION_VALIDATE(!url_.empty());
   std::string file_name = GURL(url_).ExtractFileName();
 
   std::string layout_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &layout_string));
   EXTENSION_FUNCTION_VALIDATE(!layout_string.empty());
   layout_ = GetLayoutEnum(layout_string);
 
   sequence_token_ = BrowserThread::GetBlockingPool()->
       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   task_runner->PostTask(FROM_HERE,
       base::Bind(
-          &WallpaperSetWallpaperIfExistFunction::ReadFileAndInitiateStartDecode,
+          &WallpaperPrivateSetWallpaperIfExistFunction::
+              ReadFileAndInitiateStartDecode,
           this,
           file_name));
   return true;
 }
 
-void WallpaperSetWallpaperIfExistFunction::ReadFileAndInitiateStartDecode(
-    const std::string& file_name) {
+void WallpaperPrivateSetWallpaperIfExistFunction::
+    ReadFileAndInitiateStartDecode(const std::string& file_name) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   std::string data;
   FilePath data_dir;
 
   CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &data_dir));
   FilePath file_path = data_dir.Append(file_name);
 
   if (file_util::PathExists(file_path) &&
       file_util::ReadFileToString(file_path, &data)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&WallpaperSetWallpaperIfExistFunction::StartDecode, this,
-                   data));
+        base::Bind(&WallpaperPrivateSetWallpaperIfExistFunction::StartDecode,
+                   this, data));
     return;
   }
   std::string error = base::StringPrintf(
         "Failed to set wallpaper %s from file system.", file_name.c_str());
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&WallpaperSetWallpaperIfExistFunction::OnFailureOrCancel,
+      base::Bind(&WallpaperPrivateSetWallpaperIfExistFunction::
+                 OnFailureOrCancel,
                  this, error));
 }
 
-void WallpaperSetWallpaperIfExistFunction::OnWallpaperDecoded(
+void WallpaperPrivateSetWallpaperIfExistFunction::OnWallpaperDecoded(
     const gfx::ImageSkia& wallpaper) {
   // Set wallpaper_decoder_ to null since the decoding already finished.
   wallpaper_decoder_ = NULL;
 
   chromeos::WallpaperManager* wallpaper_manager =
       chromeos::WallpaperManager::Get();
   wallpaper_manager->SetWallpaperFromImageSkia(wallpaper, layout_);
   bool is_persistent =
       !chromeos::UserManager::Get()->IsCurrentUserNonCryptohomeDataEphemeral();
   chromeos::WallpaperInfo info = {
       url_,
       layout_,
       chromeos::User::ONLINE,
       base::Time::Now().LocalMidnight()
   };
   std::string email = chromeos::UserManager::Get()->GetLoggedInUser()->email();
   wallpaper_manager->SetUserWallpaperInfo(email, info, is_persistent);
   SendResponse(true);
 }
 
-WallpaperSetWallpaperFunction::WallpaperSetWallpaperFunction() {
+WallpaperPrivateSetWallpaperFunction::WallpaperPrivateSetWallpaperFunction() {
 }
 
-WallpaperSetWallpaperFunction::~WallpaperSetWallpaperFunction() {
+WallpaperPrivateSetWallpaperFunction::~WallpaperPrivateSetWallpaperFunction() {
 }
 
-bool WallpaperSetWallpaperFunction::RunImpl() {
+bool WallpaperPrivateSetWallpaperFunction::RunImpl() {
   BinaryValue* input = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(0, &input));
 
   std::string layout_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &layout_string));
   EXTENSION_FUNCTION_VALIDATE(!layout_string.empty());
   layout_ = GetLayoutEnum(layout_string);
 
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &url_));
   EXTENSION_FUNCTION_VALIDATE(!url_.empty());
 
   // Gets email address while at UI thread.
   email_ = chromeos::UserManager::Get()->GetLoggedInUser()->email();
 
   image_data_.assign(input->GetBuffer(), input->GetSize());
   StartDecode(image_data_);
 
   return true;
 }
 
-void WallpaperSetWallpaperFunction::OnWallpaperDecoded(
+void WallpaperPrivateSetWallpaperFunction::OnWallpaperDecoded(
     const gfx::ImageSkia& wallpaper) {
   wallpaper_ = wallpaper;
   // Set wallpaper_decoder_ to null since the decoding already finished.
   wallpaper_decoder_ = NULL;
 
   sequence_token_ = BrowserThread::GetBlockingPool()->
       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
               base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 
   task_runner->PostTask(FROM_HERE,
-      base::Bind(&WallpaperSetWallpaperFunction::SaveToFile, this));
+      base::Bind(&WallpaperPrivateSetWallpaperFunction::SaveToFile, this));
 }
 
-void WallpaperSetWallpaperFunction::SaveToFile() {
+void WallpaperPrivateSetWallpaperFunction::SaveToFile() {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   std::string file_name = GURL(url_).ExtractFileName();
   if (SaveData(chrome::DIR_CHROMEOS_WALLPAPERS, file_name, image_data_)) {
     wallpaper_.EnsureRepsForSupportedScaleFactors();
     scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper_.DeepCopy());
     // ImageSkia is not RefCountedThreadSafe. Use a deep copied ImageSkia if
     // post to another thread.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&WallpaperSetWallpaperFunction::SetDecodedWallpaper,
+        base::Bind(&WallpaperPrivateSetWallpaperFunction::SetDecodedWallpaper,
                    this, base::Passed(&deep_copy)));
     chromeos::UserImage wallpaper(wallpaper_);
 
     FilePath wallpaper_dir;
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
     FilePath file_path = wallpaper_dir.Append(file_name).InsertBeforeExtension(
         chromeos::kSmallWallpaperSuffix);
     if (file_util::PathExists(file_path))
       return;
     // Generates and saves small resolution wallpaper. Uses CENTER_CROPPED to
     // maintain the aspect ratio after resize.
     chromeos::WallpaperManager::Get()->ResizeAndSaveWallpaper(
         wallpaper,
         file_path,
         ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
         ash::kSmallWallpaperMaxWidth,
         ash::kSmallWallpaperMaxHeight);
   } else {
     std::string error = base::StringPrintf(
         "Failed to create/write wallpaper to %s.", file_name.c_str());
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&WallpaperSetWallpaperFunction::OnFailureOrCancel,
+        base::Bind(&WallpaperPrivateSetWallpaperFunction::OnFailureOrCancel,
                    this, error));
   }
 }
 
-void WallpaperSetWallpaperFunction::SetDecodedWallpaper(
+void WallpaperPrivateSetWallpaperFunction::SetDecodedWallpaper(
     scoped_ptr<gfx::ImageSkia> wallpaper) {
   chromeos::WallpaperManager* wallpaper_manager =
       chromeos::WallpaperManager::Get();
   wallpaper_manager->SetWallpaperFromImageSkia(*wallpaper.get(), layout_);
   bool is_persistent =
       !chromeos::UserManager::Get()->IsCurrentUserNonCryptohomeDataEphemeral();
   chromeos::WallpaperInfo info = {
       url_,
       layout_,
       chromeos::User::ONLINE,
       base::Time::Now().LocalMidnight()
   };
   wallpaper_manager->SetUserWallpaperInfo(email_, info, is_persistent);
   SendResponse(true);
 }
 
-WallpaperSetCustomWallpaperFunction::WallpaperSetCustomWallpaperFunction() {
-}
+WallpaperPrivateSetCustomWallpaperFunction::
+    WallpaperPrivateSetCustomWallpaperFunction() {}
 
-WallpaperSetCustomWallpaperFunction::~WallpaperSetCustomWallpaperFunction() {
-}
+WallpaperPrivateSetCustomWallpaperFunction::
+    ~WallpaperPrivateSetCustomWallpaperFunction() {}
 
-bool WallpaperSetCustomWallpaperFunction::RunImpl() {
+bool WallpaperPrivateSetCustomWallpaperFunction::RunImpl() {
   BinaryValue* input = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(0, &input));
 
   std::string layout_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &layout_string));
   EXTENSION_FUNCTION_VALIDATE(!layout_string.empty());
   layout_ = GetLayoutEnum(layout_string);
 
   // Gets email address while at UI thread.
   email_ = chromeos::UserManager::Get()->GetLoggedInUser()->email();
 
   image_data_.assign(input->GetBuffer(), input->GetSize());
   StartDecode(image_data_);
 
   return true;
 }
 
-void WallpaperSetCustomWallpaperFunction::OnWallpaperDecoded(
+void WallpaperPrivateSetCustomWallpaperFunction::OnWallpaperDecoded(
     const gfx::ImageSkia& wallpaper) {
   chromeos::UserImage::RawImage raw_image(image_data_.begin(),
                                           image_data_.end());
   chromeos::UserImage image(wallpaper, raw_image);
   // In the new wallpaper picker UI, we do not depend on WallpaperDelegate
   // to refresh thumbnail. Uses a null delegate here.
   chromeos::WallpaperManager::Get()->SetCustomWallpaper(
       email_, layout_, chromeos::User::CUSTOMIZED, image);
   wallpaper_decoder_ = NULL;
   SendResponse(true);
 }
 
-WallpaperMinimizeInactiveWindowsFunction::
-    WallpaperMinimizeInactiveWindowsFunction() {
+WallpaperPrivateMinimizeInactiveWindowsFunction::
+    WallpaperPrivateMinimizeInactiveWindowsFunction() {
 }
 
-WallpaperMinimizeInactiveWindowsFunction::
-    ~WallpaperMinimizeInactiveWindowsFunction() {
+WallpaperPrivateMinimizeInactiveWindowsFunction::
+    ~WallpaperPrivateMinimizeInactiveWindowsFunction() {
 }
 
-bool WallpaperMinimizeInactiveWindowsFunction::RunImpl() {
+bool WallpaperPrivateMinimizeInactiveWindowsFunction::RunImpl() {
   WindowStateManager::MinimizeInactiveWindows();
   return true;
 }
 
-WallpaperRestoreMinimizedWindowsFunction::
-    WallpaperRestoreMinimizedWindowsFunction() {
+WallpaperPrivateRestoreMinimizedWindowsFunction::
+    WallpaperPrivateRestoreMinimizedWindowsFunction() {
 }
 
-WallpaperRestoreMinimizedWindowsFunction::
-    ~WallpaperRestoreMinimizedWindowsFunction() {
+WallpaperPrivateRestoreMinimizedWindowsFunction::
+    ~WallpaperPrivateRestoreMinimizedWindowsFunction() {
 }
 
-bool WallpaperRestoreMinimizedWindowsFunction::RunImpl() {
+bool WallpaperPrivateRestoreMinimizedWindowsFunction::RunImpl() {
   WindowStateManager::RestoreWindows();
   return true;
 }
 
-WallpaperGetThumbnailFunction::WallpaperGetThumbnailFunction() {
+WallpaperPrivateGetThumbnailFunction::WallpaperPrivateGetThumbnailFunction() {
 }
 
-WallpaperGetThumbnailFunction::~WallpaperGetThumbnailFunction() {
+WallpaperPrivateGetThumbnailFunction::~WallpaperPrivateGetThumbnailFunction() {
 }
 
-bool WallpaperGetThumbnailFunction::RunImpl() {
+bool WallpaperPrivateGetThumbnailFunction::RunImpl() {
   std::string url;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url));
   EXTENSION_FUNCTION_VALIDATE(!url.empty());
   std::string file_name = GURL(url).ExtractFileName();
   sequence_token_ = BrowserThread::GetBlockingPool()->
       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   task_runner->PostTask(FROM_HERE,
-      base::Bind(&WallpaperGetThumbnailFunction::Get, this, file_name));
+      base::Bind(&WallpaperPrivateGetThumbnailFunction::Get, this, file_name));
   return true;
 }
 
-void WallpaperGetThumbnailFunction::Failure(const std::string& file_name) {
+void WallpaperPrivateGetThumbnailFunction::Failure(
+    const std::string& file_name) {
   SetError(base::StringPrintf("Failed to access wallpaper thumbnails for %s.",
                               file_name.c_str()));
   SendResponse(false);
 }
 
-void WallpaperGetThumbnailFunction::FileNotLoaded() {
+void WallpaperPrivateGetThumbnailFunction::FileNotLoaded() {
   SendResponse(true);
 }
 
-void WallpaperGetThumbnailFunction::FileLoaded(const std::string& data) {
+void WallpaperPrivateGetThumbnailFunction::FileLoaded(
+    const std::string& data) {
   BinaryValue* thumbnail = BinaryValue::CreateWithCopiedBuffer(data.c_str(),
                                                                data.size());
   SetResult(thumbnail);
   SendResponse(true);
 }
 
-void WallpaperGetThumbnailFunction::Get(const std::string& file_name) {
+void WallpaperPrivateGetThumbnailFunction::Get(const std::string& file_name) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   std::string data;
   if (GetData(chrome::DIR_CHROMEOS_WALLPAPER_THUMBNAILS, file_name, &data)) {
     if (data.empty()) {
       BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&WallpaperGetThumbnailFunction::FileNotLoaded, this));
+        base::Bind(&WallpaperPrivateGetThumbnailFunction::FileNotLoaded, this));
     } else {
       BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&WallpaperGetThumbnailFunction::FileLoaded, this, data));
+        base::Bind(&WallpaperPrivateGetThumbnailFunction::FileLoaded, this,
+                   data));
     }
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&WallpaperGetThumbnailFunction::Failure, this, file_name));
+        base::Bind(&WallpaperPrivateGetThumbnailFunction::Failure, this,
+                   file_name));
   }
 }
 
-WallpaperSaveThumbnailFunction::WallpaperSaveThumbnailFunction() {
+WallpaperPrivateSaveThumbnailFunction::WallpaperPrivateSaveThumbnailFunction() {
 }
 
-WallpaperSaveThumbnailFunction::~WallpaperSaveThumbnailFunction() {
-}
+WallpaperPrivateSaveThumbnailFunction::
+    ~WallpaperPrivateSaveThumbnailFunction() {}
 
-bool WallpaperSaveThumbnailFunction::RunImpl() {
+bool WallpaperPrivateSaveThumbnailFunction::RunImpl() {
   std::string url;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url));
   EXTENSION_FUNCTION_VALIDATE(!url.empty());
 
   BinaryValue* input = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &input));
 
   std::string file_name = GURL(url).ExtractFileName();
   std::string data(input->GetBuffer(), input->GetSize());
 
   sequence_token_ = BrowserThread::GetBlockingPool()->
       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   task_runner->PostTask(FROM_HERE,
-      base::Bind(&WallpaperSaveThumbnailFunction::Save,
+      base::Bind(&WallpaperPrivateSaveThumbnailFunction::Save,
                  this, data, file_name));
   return true;
 }
 
-void WallpaperSaveThumbnailFunction::Failure(const std::string& file_name) {
+void WallpaperPrivateSaveThumbnailFunction::Failure(
+    const std::string& file_name) {
   SetError(base::StringPrintf("Failed to create/write thumbnail of %s.",
                               file_name.c_str()));
   SendResponse(false);
 }
 
-void WallpaperSaveThumbnailFunction::Success() {
+void WallpaperPrivateSaveThumbnailFunction::Success() {
   SendResponse(true);
 }
 
-void WallpaperSaveThumbnailFunction::Save(const std::string& data,
+void WallpaperPrivateSaveThumbnailFunction::Save(const std::string& data,
                                           const std::string& file_name) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   if (SaveData(chrome::DIR_CHROMEOS_WALLPAPER_THUMBNAILS, file_name, data)) {
     BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&WallpaperSaveThumbnailFunction::Success, this));
+      base::Bind(&WallpaperPrivateSaveThumbnailFunction::Success, this));
   } else {
     BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
-          base::Bind(&WallpaperSaveThumbnailFunction::Failure,
+          base::Bind(&WallpaperPrivateSaveThumbnailFunction::Failure,
                      this, file_name));
   }
 }
 
-WallpaperGetOfflineWallpaperListFunction::
-    WallpaperGetOfflineWallpaperListFunction() {
+WallpaperPrivateGetOfflineWallpaperListFunction::
+    WallpaperPrivateGetOfflineWallpaperListFunction() {
 }
 
-WallpaperGetOfflineWallpaperListFunction::
-    ~WallpaperGetOfflineWallpaperListFunction() {
+WallpaperPrivateGetOfflineWallpaperListFunction::
+    ~WallpaperPrivateGetOfflineWallpaperListFunction() {
 }
 
-bool WallpaperGetOfflineWallpaperListFunction::RunImpl() {
+bool WallpaperPrivateGetOfflineWallpaperListFunction::RunImpl() {
   sequence_token_ = BrowserThread::GetBlockingPool()->
       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   task_runner->PostTask(FROM_HERE,
-      base::Bind(&WallpaperGetOfflineWallpaperListFunction::GetList, this));
+      base::Bind(&WallpaperPrivateGetOfflineWallpaperListFunction::GetList,
+                 this));
   return true;
 }
 
-void WallpaperGetOfflineWallpaperListFunction::GetList() {
+void WallpaperPrivateGetOfflineWallpaperListFunction::GetList() {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   FilePath wallpaper_dir;
   std::vector<std::string> file_list;
   CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
   if (file_util::DirectoryExists(wallpaper_dir)) {
     file_util::FileEnumerator files(wallpaper_dir, false,
                                     file_util::FileEnumerator::FILES);
     for (FilePath current = files.Next(); !current.empty();
          current = files.Next()) {
       std::string file_name = current.BaseName().RemoveExtension().value();
       // Do not add file name of small resolution wallpaper to the list.
       if (!EndsWith(file_name, chromeos::kSmallWallpaperSuffix, true))
         file_list.push_back(current.BaseName().value());
     }
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&WallpaperGetOfflineWallpaperListFunction::OnComplete,
+      base::Bind(&WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete,
                  this, file_list));
 }
 
-void WallpaperGetOfflineWallpaperListFunction::OnComplete(
+void WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete(
     const std::vector<std::string>& file_list) {
   ListValue* results = new ListValue();
   results->AppendStrings(file_list);
   SetResult(results);
   SendResponse(true);
 }