Run the JSON Schema Compiler's bundle compilation on JSON files. Previously it

chrome/browser/extensions/api/bookmarks/bookmarks_api.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/extensions/api/bookmarks/bookmark_api.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmarks_api.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/public/pref_service_base.h"
 #include "base/sha1.h"
@@ skipping 280 matching lines @@
 void BookmarkAPI::Shutdown() {
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
 }
 
 void BookmarkAPI::OnListenerAdded(const EventListenerInfo& details) {
   bookmark_event_router_.reset(new BookmarkEventRouter(
       BookmarkModelFactory::GetForProfile(profile_)));
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
 }
 
-bool GetBookmarksFunction::RunImpl() {
+bool BookmarksGetTreeFunction::RunImpl() {
   scoped_ptr<bookmarks::Get::Params> params(
       bookmarks::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   if (params->id_or_id_list_type ==
       bookmarks::Get::Params::ID_OR_ID_LIST_ARRAY) {
     std::vector<std::string>* ids = params->id_or_id_list_array.get();
     size_t count = ids->size();
@@ skipping 19 matching lines @@
       error_ = keys::kNoNodeError;
       return false;
     }
     bookmark_api_helpers::AddNode(node, &nodes, false);
   }
 
   results_ = bookmarks::Get::Results::Create(nodes);
   return true;
 }
 
-bool GetBookmarkChildrenFunction::RunImpl() {
+bool BookmarksGetChildrenFunction::RunImpl() {
   scoped_ptr<bookmarks::GetChildren::Params> params(
       bookmarks::GetChildren::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!GetBookmarkIdAsInt64(params->id, &id))
     return false;
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   const BookmarkNode* node =
       BookmarkModelFactory::GetForProfile(profile())->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
     return false;
   }
   int child_count = node->child_count();
   for (int i = 0; i < child_count; ++i) {
     const BookmarkNode* child = node->GetChild(i);
     bookmark_api_helpers::AddNode(child, &nodes, false);
   }
 
   results_ = bookmarks::GetChildren::Results::Create(nodes);
   return true;
 }
 
-bool GetBookmarkRecentFunction::RunImpl() {
+bool BookmarksGetFunction::RunImpl() {
   scoped_ptr<bookmarks::GetRecent::Params> params(
       bookmarks::GetRecent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->number_of_items < 1)
     return false;
 
   std::vector<const BookmarkNode*> nodes;
   bookmark_utils::GetMostRecentlyAddedEntries(
       BookmarkModelFactory::GetForProfile(profile()),
       params->number_of_items,
       &nodes);
 
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
   std::vector<const BookmarkNode*>::iterator i = nodes.begin();
   for (; i != nodes.end(); ++i) {
     const BookmarkNode* node = *i;
     bookmark_api_helpers::AddNode(node, &tree_nodes, false);
   }
 
   results_ = bookmarks::GetRecent::Results::Create(tree_nodes);
   return true;
 }
 
-bool GetBookmarkTreeFunction::RunImpl() {
+bool BookmarksGetSubTreeFunction::RunImpl() {
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   const BookmarkNode* node =
       BookmarkModelFactory::GetForProfile(profile())->root_node();
   bookmark_api_helpers::AddNode(node, &nodes, true);
   results_ = bookmarks::GetTree::Results::Create(nodes);
   return true;
 }
 
-bool GetBookmarkSubTreeFunction::RunImpl() {
+bool BookmarksGetRecentFunction::RunImpl() {
   scoped_ptr<bookmarks::GetSubTree::Params> params(
       bookmarks::GetSubTree::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!GetBookmarkIdAsInt64(params->id, &id))
     return false;
 
   const BookmarkNode* node =
       BookmarkModelFactory::GetForProfile(profile())->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
     return false;
   }
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   bookmark_api_helpers::AddNode(node, &nodes, true);
   results_ = bookmarks::GetSubTree::Results::Create(nodes);
   return true;
 }
 
-bool SearchBookmarksFunction::RunImpl() {
+bool BookmarksSearchFunction::RunImpl() {
   scoped_ptr<bookmarks::Search::Params> params(
       bookmarks::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   PrefServiceBase* prefs = PrefServiceBase::FromBrowserContext(profile_);
   std::string lang = prefs->GetString(prefs::kAcceptLanguages);
   std::vector<const BookmarkNode*> nodes;
   bookmark_utils::GetBookmarksContainingText(
       BookmarkModelFactory::GetForProfile(profile()),
       UTF8ToUTF16(params->query),
       std::numeric_limits<int>::max(),
       lang,
       &nodes);
 
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
   for (std::vector<const BookmarkNode*>::iterator node_iter = nodes.begin();
        node_iter != nodes.end(); ++node_iter) {
     bookmark_api_helpers::AddNode(*node_iter, &tree_nodes, false);
   }
 
   results_ = bookmarks::Search::Results::Create(tree_nodes);
   return true;
 }
 
 // static
-bool RemoveBookmarkFunction::ExtractIds(const ListValue* args,
+bool BookmarksRemoveFunction::ExtractIds(const ListValue* args,
                                         std::list<int64>* ids,
                                         bool* invalid_id) {
   std::string id_string;
   if (!args->GetString(0, &id_string))
     return false;
   int64 id;
   if (base::StringToInt64(id_string, &id))
     ids->push_back(id);
   else
     *invalid_id = true;
   return true;
 }
 
-bool RemoveBookmarkFunction::RunImpl() {
+bool BookmarksRemoveFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
 
   scoped_ptr<bookmarks::Remove::Params> params(
       bookmarks::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!base::StringToInt64(params->id, &id)) {
     error_ = keys::kInvalidIdError;
     return false;
   }
 
   bool recursive = false;
-  if (name() == RemoveTreeBookmarkFunction::function_name())
+  if (name() == BookmarksRemoveTreeFunction::function_name())
     recursive = true;
 
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   if (!bookmark_api_helpers::RemoveNode(model, id, recursive, &error_))
     return false;
 
   return true;
 }
 
-bool CreateBookmarkFunction::RunImpl() {
+bool BookmarksCreateFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
 
   scoped_ptr<bookmarks::Create::Params> params(
       bookmarks::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   int64 parentId;
 
@@ skipping 51 matching lines @@
   }
 
   scoped_ptr<BookmarkTreeNode> ret(
       bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   results_ = bookmarks::Create::Results::Create(*ret);
 
   return true;
 }
 
 // static
-bool MoveBookmarkFunction::ExtractIds(const ListValue* args,
+bool BookmarksMoveFunction::ExtractIds(const ListValue* args,
                                       std::list<int64>* ids,
                                       bool* invalid_id) {
   // For now, Move accepts ID parameters in the same way as an Update.
-  return UpdateBookmarkFunction::ExtractIds(args, ids, invalid_id);
+  return BookmarksUpdateFunction::ExtractIds(args, ids, invalid_id);
 }
 
-bool MoveBookmarkFunction::RunImpl() {
+bool BookmarksMoveFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
 
   scoped_ptr<bookmarks::Move::Params> params(
       bookmarks::Move::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!base::StringToInt64(params->id, &id)) {
     error_ = keys::kInvalidIdError;
@@ skipping 46 matching lines @@
   model->Move(node, parent, index);
 
   scoped_ptr<BookmarkTreeNode> tree_node(
       bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   results_ = bookmarks::Move::Results::Create(*tree_node);
 
   return true;
 }
 
 // static
-bool UpdateBookmarkFunction::ExtractIds(const ListValue* args,
+bool BookmarksUpdateFunction::ExtractIds(const ListValue* args,
                                         std::list<int64>* ids,
                                         bool* invalid_id) {
   // For now, Update accepts ID parameters in the same way as an Remove.
-  return RemoveBookmarkFunction::ExtractIds(args, ids, invalid_id);
+  return BookmarksRemoveFunction::ExtractIds(args, ids, invalid_id);
 }
 
-bool UpdateBookmarkFunction::RunImpl() {
+bool BookmarksUpdateFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
 
   scoped_ptr<bookmarks::Update::Params> params(
       bookmarks::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!base::StringToInt64(params->id, &id)) {
     error_ = keys::kInvalidIdError;
@@ skipping 56 matching lines @@
   }
  private:
   std::map<BucketIdType, Bucket*> buckets_;
 };
 
 // Mapper for 'bookmarks.create'.  Maps "same input to bookmarks.create" to a
 // unique bucket.
 class CreateBookmarkBucketMapper : public BookmarkBucketMapper<std::string> {
  public:
   explicit CreateBookmarkBucketMapper(Profile* profile) : profile_(profile) {}
-  // TODO(tim): This should share code with CreateBookmarkFunction::RunImpl,
+  // TODO(tim): This should share code with BookmarksCreateFunction::RunImpl,
   // but I can't figure out a good way to do that with all the macros.
   virtual void GetBucketsForArgs(const ListValue* args, BucketList* buckets) {
     const DictionaryValue* json;
     if (!args->GetDictionary(0, &json))
       return;
 
     std::string parent_id;
     if (json->HasKey(keys::kParentIdKey)) {
       if (!json->GetString(keys::kParentIdKey, &parent_id))
         return;
@@ skipping 23 matching lines @@
 };
 
 // Mapper for 'bookmarks.remove'.
 class RemoveBookmarksBucketMapper : public BookmarkBucketMapper<std::string> {
  public:
   explicit RemoveBookmarksBucketMapper(Profile* profile) : profile_(profile) {}
   virtual void GetBucketsForArgs(const ListValue* args, BucketList* buckets) {
     typedef std::list<int64> IdList;
     IdList ids;
     bool invalid_id = false;
-    if (!RemoveBookmarkFunction::ExtractIds(args, &ids, &invalid_id) ||
+    if (!BookmarksRemoveFunction::ExtractIds(args, &ids, &invalid_id) ||
         invalid_id) {
       return;
     }
 
     for (IdList::iterator it = ids.begin(); it != ids.end(); ++it) {
       BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile_);
       const BookmarkNode* node = model->GetNodeByID(*it);
       if (!node || node->is_root())
         return;
 
@@ skipping 72 matching lines @@
     heuristics->push_back(new TimedLimit(
         kTimedLimitConfig,
         long_mapper,
         "MAX_WRITE_OPERATIONS_PER_HOUR"));
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BookmarksQuotaLimitFactory);
 };
 
 // And finally, building the individual heuristics for each function.
-void RemoveBookmarkFunction::GetQuotaLimitHeuristics(
+void BookmarksRemoveFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   BookmarksQuotaLimitFactory::BuildForRemove(heuristics, profile());
 }
 
-void MoveBookmarkFunction::GetQuotaLimitHeuristics(
+void BookmarksMoveFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
-  BookmarksQuotaLimitFactory::Build<MoveBookmarkFunction>(heuristics);
+  BookmarksQuotaLimitFactory::Build<BookmarksMoveFunction>(heuristics);
 }
 
-void UpdateBookmarkFunction::GetQuotaLimitHeuristics(
+void BookmarksUpdateFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
-  BookmarksQuotaLimitFactory::Build<UpdateBookmarkFunction>(heuristics);
+  BookmarksQuotaLimitFactory::Build<BookmarksUpdateFunction>(heuristics);
 };
 
-void CreateBookmarkFunction::GetQuotaLimitHeuristics(
+void BookmarksCreateFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   BookmarksQuotaLimitFactory::BuildForCreate(heuristics, profile());
 }
 
 BookmarksIOFunction::BookmarksIOFunction() {}
 
 BookmarksIOFunction::~BookmarksIOFunction() {
   // There may be pending file dialogs, we need to tell them that we've gone
   // away so they don't try and call back to us.
   if (select_file_dialog_.get())
@@ skipping 57 matching lines @@
 void BookmarksIOFunction::FileSelectionCanceled(void* params) {
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 void BookmarksIOFunction::MultiFilesSelected(
     const std::vector<FilePath>& files, void* params) {
   Release();  // Balanced in BookmarsIOFunction::SelectFile()
   NOTREACHED() << "Should not be able to select multiple files";
 }
 
-bool ImportBookmarksFunction::RunImpl() {
+bool BookmarksImportFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
   SelectFile(ui::SelectFileDialog::SELECT_OPEN_FILE);
   return true;
 }
 
-void ImportBookmarksFunction::FileSelected(const FilePath& path,
+void BookmarksImportFunction::FileSelected(const FilePath& path,
                                            int index,
                                            void* params) {
 #if !defined(OS_ANDROID)
   // Android does not have support for the standard importers.
   // TODO(jgreenwald): remove ifdef once extensions are no longer built on
   // Android.
   scoped_refptr<ImporterHost> importer_host(new ImporterHost);
   importer::SourceProfile source_profile;
   source_profile.importer_type = importer::TYPE_BOOKMARKS_FILE;
   source_profile.source_path = path;
   importer_host->StartImportSettings(source_profile,
                                      profile(),
                                      importer::FAVORITES,
                                      new ProfileWriter(profile()),
                                      true);
 #endif
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
-bool ExportBookmarksFunction::RunImpl() {
+bool BookmarksExportFunction::RunImpl() {
   SelectFile(ui::SelectFileDialog::SELECT_SAVEAS_FILE);
   return true;
 }
 
-void ExportBookmarksFunction::FileSelected(const FilePath& path,
+void BookmarksExportFunction::FileSelected(const FilePath& path,
                                            int index,
                                            void* params) {
 #if !defined(OS_ANDROID)
   // Android does not have support for the standard exporter.
   // TODO(jgreenwald): remove ifdef once extensions are no longer built on
   // Android.
   bookmark_html_writer::WriteBookmarks(profile(), path, NULL);
 #endif
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 }  // namespace extensions