Add API function chrome.notifications.getAll

chrome/browser/extensions/api/notifications/notifications_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/notifications/notifications_api.h"
 
 #include "base/callback.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/render_view_host.h"
 #include "googleurl/src/gurl.h"
 #include "ui/message_center/message_center_util.h"
 
 namespace extensions {
 
 namespace {
 
 const char kResultKey[] = "result";
 
+// Given an extension id and another id, returns an id that is unique
+// relative to other extensions.
+std::string CreateScopedIdentifier(const std::string& extension_id,
+                                   const std::string& id) {
+  return extension_id + "-" + id;
+}
+
+// Removes the unique internal identifier to send the ID as the
+// extension expects it.
+std::string StripScopeFromIdentifier(const std::string& extension_id,
+                                     const std::string& id) {
+  size_t index_of_separator = extension_id.length() + 1;
+  DCHECK_LT(index_of_separator, id.length());
+
+  return id.substr(index_of_separator);
+}
+
 class NotificationsApiDelegate : public NotificationDelegate {
  public:
   NotificationsApiDelegate(ApiFunction* api_function,
                           Profile* profile,
                           const std::string& extension_id,
                           const std::string& id)
       : api_function_(api_function),
         profile_(profile),
         extension_id_(extension_id),
         id_(id),
         scoped_id_(CreateScopedIdentifier(extension_id, id)),
         process_id_(-1) {
     DCHECK(api_function_);
     if (api_function_->render_view_host())
       process_id_ = api_function->render_view_host()->GetProcess()->GetID();
   }
 
-  // Given an extension id and another id, returns an id that is unique
-  // relative to other extensions.
-  static std::string CreateScopedIdentifier(const std::string& extension_id,
-                                            const std::string& id) {
-    return extension_id + "-" + id;
-  }
-
   virtual void Display() OVERRIDE { }
 
   virtual void Error() OVERRIDE {
     scoped_ptr<ListValue> args(CreateBaseEventArgs());
     SendEvent(event_names::kOnNotificationError, args.Pass());
   }
 
   virtual void Close(bool by_user) OVERRIDE {
     scoped_ptr<ListValue> args(CreateBaseEventArgs());
     args->Append(Value::CreateBooleanValue(by_user));
@@ skipping 57 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(NotificationsApiDelegate);
 };
 
 }  // namespace
 
 bool NotificationsApiFunction::IsNotificationsApiAvailable() {
   // We need to check this explicitly rather than letting
   // _permission_features.json enforce it, because we're sharing the
   // chrome.notifications permissions namespace with WebKit notifications.
-  if (!(GetExtension()->is_platform_app() || GetExtension()->is_extension()))
-    return false;
-
-  return true;
+  return GetExtension()->is_platform_app() || GetExtension()->is_extension();
 }
 
 NotificationsApiFunction::NotificationsApiFunction() {
 }
 
 NotificationsApiFunction::~NotificationsApiFunction() {
 }
 
 void NotificationsApiFunction::CreateNotification(
     const std::string& id,
@@ skipping 176 matching lines @@
 NotificationsUpdateFunction::NotificationsUpdateFunction() {
 }
 
 NotificationsUpdateFunction::~NotificationsUpdateFunction() {
 }
 
 bool NotificationsUpdateFunction::RunNotificationsApi() {
   params_ = api::notifications::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
-  if (g_browser_process->notification_ui_manager()->
-      DoesIdExist(NotificationsApiDelegate::CreateScopedIdentifier(
-          extension_->id(), params_->notification_id))) {
+  if (g_browser_process->notification_ui_manager()->DoesIdExist(
+          CreateScopedIdentifier(extension_->id(), params_->notification_id))) {
     CreateNotification(params_->notification_id, &params_->options);
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
 
   SendResponse(true);
 
   return true;
 }
 
 NotificationsClearFunction::NotificationsClearFunction() {
 }
 
 NotificationsClearFunction::~NotificationsClearFunction() {
 }
 
 bool NotificationsClearFunction::RunNotificationsApi() {
   params_ = api::notifications::Clear::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
-  bool cancel_result = g_browser_process->notification_ui_manager()->
-      CancelById(NotificationsApiDelegate::CreateScopedIdentifier(
-          extension_->id(), params_->notification_id));
+  bool cancel_result = g_browser_process->notification_ui_manager()->CancelById(
+      CreateScopedIdentifier(extension_->id(), params_->notification_id));
 
   SetResult(Value::CreateBooleanValue(cancel_result));
   SendResponse(true);
 
   return true;
 }
 
+NotificationsGetAllFunction::NotificationsGetAllFunction() {}
+
+NotificationsGetAllFunction::~NotificationsGetAllFunction() {}
+
+bool NotificationsGetAllFunction::RunNotificationsApi() {
+  std::set<std::string> notification_ids;
+  NotificationUIManager* notification_ui_manager =
+      g_browser_process->notification_ui_manager();
+  notification_ui_manager->GetAllIdsByProfileAndSourceOrigin(
+      profile_, extension_->url(), &notification_ids);
+
+  scoped_ptr<DictionaryValue> result(new DictionaryValue());
+
+  for (std::set<std::string>::iterator iter = notification_ids.begin();
+       iter != notification_ids.end();
+       iter++) {

[Dmitry Titov, 2013/05/16 20:39:15]

nit: Most often, this loop is split in 2 lines, not 3...

[dewittj, 2013/05/16 23:40:34]

ALL HAIL CLANG-FORMAT-DIFF

+    result->SetBooleanWithoutPathExpansion(
+        StripScopeFromIdentifier(extension_->id(), *iter), true);

[Dmitry Titov, 2013/05/16 20:39:15]

Just a note: this makes me think we might want to clean up the way we use
various 'id's in Notifications. It would be better to store/roundtrip the values
without combining/splitting them in strings, and explicitly consider the
required equality checks. For example, we have 2  implementations for 'update
match' - one that checks extension_id+id (here, in ClearFunction for example),
another also checks associated profile equality (in
MessageCenterNotificationManager::UpdateNotification). This means at least one
of these places has a bug :-)

But this can be done in a separate patch[es]. Here you use the current profile
which I think is correct.

[dewittj, 2013/05/16 23:40:34]

I agree, but it is indeed better done in a separate patch.

+  }
+
+  SetResult(result.release());
+  SendResponse(true);
+
+  return true;
+}
+
 }  // namespace extensions