Implement remaining chrome.searchEnginesPrivate methods.

chrome/browser/extensions/api/search_engines_private/search_engines_private_event_router.cc

Index: chrome/browser/extensions/api/search_engines_private/search_engines_private_event_router.cc
diff --git a/chrome/browser/extensions/api/search_engines_private/search_engines_private_event_router.cc b/chrome/browser/extensions/api/search_engines_private/search_engines_private_event_router.cc
index ac623895537db3f297dd08b5fd9a870528fd414d..a1e6ec6cd8ecb2a47a59f6d0897e07201e38283a 100644
--- a/chrome/browser/extensions/api/search_engines_private/search_engines_private_event_router.cc
+++ b/chrome/browser/extensions/api/search_engines_private/search_engines_private_event_router.cc
@@ -17,11 +17,14 @@
 
 namespace extensions {
 
+namespace search_engines_private = api::search_engines_private;
+
 SearchEnginesPrivateEventRouter::SearchEnginesPrivateEventRouter(
     content::BrowserContext* context)
     : template_url_service_(nullptr),
       context_(context),
-      listening_(false) {
+      listening_for_default_(false),
+      listening_for_others_(false) {
   // Register with the event router so we know when renderers are listening to
   // our events. We first check and see if there *is* an event router, because
   // some unit tests try to create all context services, but don't initialize
@@ -31,15 +34,17 @@ SearchEnginesPrivateEventRouter::SearchEnginesPrivateEventRouter(
     return;
 
   event_router->RegisterObserver(
-      this,
-      api::search_engines_private::OnDefaultSearchEnginesChanged::kEventName);
+      this, search_engines_private::OnDefaultSearchEnginesChanged::kEventName);
+  event_router->RegisterObserver(
+      this, search_engines_private::OnOtherSearchEnginesChanged::kEventName);
   template_url_service_ = TemplateURLServiceFactory::GetForProfile(
       Profile::FromBrowserContext(context_));
   StartOrStopListeningForSearchEnginesChanges();
 }
 
 SearchEnginesPrivateEventRouter::~SearchEnginesPrivateEventRouter() {
-  DCHECK(!listening_);
+  DCHECK(!listening_for_default_);
+  DCHECK(!listening_for_others_);
 }
 
 void SearchEnginesPrivateEventRouter::Shutdown() {
@@ -50,10 +55,11 @@ void SearchEnginesPrivateEventRouter::Shutdown() {
   if (event_router)
     event_router->UnregisterObserver(this);
 
-  if (listening_)
+  if (listening_for_default_ || listening_for_others_)
     template_url_service_->RemoveObserver(this);
 
-  listening_ = false;
+  listening_for_default_ = false;
+  listening_for_others_ = false;

[stevenjb, 2015/04/28 17:16:39]

We could also avoid the added complexity in this class if we pass and update a
single list in the API and move the list separation to the JS.

 }
 
 void SearchEnginesPrivateEventRouter::OnListenerAdded(
@@ -76,42 +82,68 @@ void SearchEnginesPrivateEventRouter::OnTemplateURLServiceChanged() {
       template_url_service_->GetDefaultSearchProvider();
   std::vector<TemplateURL*> urls = template_url_service_->GetTemplateURLs();
 
-  std::vector<linked_ptr<api::search_engines_private::SearchEngine>> engines;
+  std::vector<linked_ptr<search_engines_private::SearchEngine>> default_engines;
+  std::vector<linked_ptr<search_engines_private::SearchEngine>> other_engines;
+
   for (TemplateURL* url : urls) {
-    api::search_engines_private::SearchEngine* engine =
-        new api::search_engines_private::SearchEngine();
+    search_engines_private::SearchEngine* engine =
+        new search_engines_private::SearchEngine();
     engine->guid = url->sync_guid();
     engine->name = base::UTF16ToASCII(url->short_name());
+    engine->keyword = base::UTF16ToASCII(url->keyword());
+    engine->url = url->url();
     if (url == default_url)
       engine->is_selected = scoped_ptr<bool>(new bool(true));
 
-    engines.push_back(
-        linked_ptr<api::search_engines_private::SearchEngine>(engine));
+    linked_ptr<search_engines_private::SearchEngine> engine_ptr(engine);
+
+    if (url->show_in_default_list()) {
+      default_engines.push_back(engine_ptr);
+    } else {
+      other_engines.push_back(engine_ptr);
+    }
   }
 
-  scoped_ptr<base::ListValue> args(
-      api::search_engines_private::OnDefaultSearchEnginesChanged::Create(
-          engines));
+  if (!default_engines.empty()) {
+    scoped_ptr<base::ListValue> args(
+        search_engines_private::OnDefaultSearchEnginesChanged::Create(
+            default_engines));
+    scoped_ptr<Event> extension_event(new Event(
+        search_engines_private::OnDefaultSearchEnginesChanged::kEventName,
+        args.Pass()));
+    EventRouter::Get(context_)->BroadcastEvent(extension_event.Pass());
+  }
 
-  scoped_ptr<Event> extension_event(new Event(
-      api::search_engines_private::OnDefaultSearchEnginesChanged::kEventName,
-      args.Pass()));
-  EventRouter::Get(context_)->BroadcastEvent(extension_event.Pass());
+  if (!other_engines.empty()) {
+    scoped_ptr<base::ListValue> args(
+        search_engines_private::OnOtherSearchEnginesChanged::Create(
+            other_engines));
+    scoped_ptr<Event> extension_event(new Event(
+        search_engines_private::OnOtherSearchEnginesChanged::kEventName,
+        args.Pass()));
+    EventRouter::Get(context_)->BroadcastEvent(extension_event.Pass());
+  }
 }
 
 void SearchEnginesPrivateEventRouter::
     StartOrStopListeningForSearchEnginesChanges() {
   EventRouter* event_router = EventRouter::Get(context_);
-  bool should_listen = event_router->HasEventListener(
-      api::search_engines_private::OnDefaultSearchEnginesChanged::kEventName);
+  bool should_listen_for_default = event_router->HasEventListener(
+      search_engines_private::OnDefaultSearchEnginesChanged::kEventName);
+  bool should_listen_for_others = event_router->HasEventListener(
+      search_engines_private::OnOtherSearchEnginesChanged::kEventName);
+  bool should_listen = should_listen_for_default || should_listen_for_others;
 
-  if (should_listen && !listening_) {
+  if (should_listen && !listening_for_default_ && !listening_for_others_) {
     template_url_service_->Load();
     template_url_service_->AddObserver(this);
-  } else if (!should_listen && listening_) {
+  } else if (!should_listen &&
+             (listening_for_default_ || listening_for_others_)) {
     template_url_service_->RemoveObserver(this);
   }
-  listening_ = should_listen;
+
+  listening_for_default_ = should_listen_for_default;
+  listening_for_others_ = should_listen_for_others;
 }
 
 SearchEnginesPrivateEventRouter* SearchEnginesPrivateEventRouter::Create(