Revert 201932 "Add API function chrome.notifications.getAll"

trunk/src/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 62 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.
-  return GetExtension()->is_platform_app() || GetExtension()->is_extension();
+  if (!(GetExtension()->is_platform_app() || GetExtension()->is_extension()))
+    return false;
+
+  return true;
 }
 
 NotificationsApiFunction::NotificationsApiFunction() {
 }
 
 NotificationsApiFunction::~NotificationsApiFunction() {
 }
 
 void NotificationsApiFunction::CreateNotification(
     const std::string& id,
@@ skipping 174 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(
-          CreateScopedIdentifier(extension_->id(), params_->notification_id))) {
+  if (g_browser_process->notification_ui_manager()->
+      DoesIdExist(NotificationsApiDelegate::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(
-      CreateScopedIdentifier(extension_->id(), params_->notification_id));
+  bool cancel_result = g_browser_process->notification_ui_manager()->
+      CancelById(NotificationsApiDelegate::CreateScopedIdentifier(
+          extension_->id(), params_->notification_id));
 
   SetResult(Value::CreateBooleanValue(cancel_result));
   SendResponse(true);
 
   return true;
 }
 
-NotificationsGetAllFunction::NotificationsGetAllFunction() {}
-
-NotificationsGetAllFunction::~NotificationsGetAllFunction() {}
-
-bool NotificationsGetAllFunction::RunNotificationsApi() {
-  NotificationUIManager* notification_ui_manager =
-      g_browser_process->notification_ui_manager();
-  std::set<std::string> notification_ids =
-      notification_ui_manager->GetAllIdsByProfileAndSourceOrigin(
-          profile_, extension_->url());
-
-  scoped_ptr<DictionaryValue> result(new DictionaryValue());
-
-  for (std::set<std::string>::iterator iter = notification_ids.begin();
-       iter != notification_ids.end(); iter++) {
-    result->SetBooleanWithoutPathExpansion(
-        StripScopeFromIdentifier(extension_->id(), *iter), true);
-  }
-
-  SetResult(result.release());
-  SendResponse(true);
-
-  return true;
-}
-
 }  // namespace extensions