Actually prevent sending notifications from apps.

chrome/browser/extensions/api/notification/notification_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/notification/notification_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"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/notifications/desktop_notification_service.h"
+#include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/common/extensions/extension.h"
 #include "googleurl/src/gurl.h"
 #include "ui/notifications/notification_types.h"
 
 namespace extensions {
 
 namespace {
 
@@ skipping 163 matching lines @@
       extension_->id(),
       id));  // ownership is passed to Notification
   Notification notification(type, extension_->url(), icon_url, title, message,
                             WebKit::WebTextDirectionDefault,
                             string16(), UTF8ToUTF16(api_delegate->id()),
                             optional_fields.get(), api_delegate);
 
   g_browser_process->notification_ui_manager()->Add(notification, profile());
 }
 
+bool NotificationApiFunction::IsNotificationApiEnabled() {
+  DesktopNotificationService* service =
+      DesktopNotificationServiceFactory::GetForProfile(profile());
+  return service->IsExtensionEnabled(extension_->id());
+}
+
 const char kNotificationPrefix[] = "extension.api.";
 
 static uint64 next_id_ = 0;
 
 NotificationCreateFunction::NotificationCreateFunction() {
 }
 
 NotificationCreateFunction::~NotificationCreateFunction() {
 }
 
 bool NotificationCreateFunction::RunImpl() {
   params_ = api::experimental_notification::Create::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
+  if (!IsNotificationApiEnabled()) {

[miket_OOO, 2013/02/11 23:04:20]

If you think this should be enforced for all NotificationApiFunctions, you could
change RunImpl() to do this automatically. I think it's also OK as-is.

[Jun Mukai, 2013/02/12 01:09:02]

That sounds reasonable. Fixed the code based on your idea. Can you take another
look?

+    SendResponse(false);
+    return true;
+  }
+
   // If the caller provided a notificationId, use that. Otherwise, generate
   // one. Note that there's nothing stopping an app developer from passing in
   // arbitrary "extension.api.999" notificationIds that will collide with
   // future generated IDs. It doesn't seem necessary to try to prevent this; if
   // developers want to hurt themselves, we'll let them.
   const std::string extension_id(extension_->id());
   std::string notification_id;
   if (!params_->notification_id.empty())
     notification_id = params_->notification_id;
   else
@@ skipping 11 matching lines @@
 NotificationUpdateFunction::NotificationUpdateFunction() {
 }
 
 NotificationUpdateFunction::~NotificationUpdateFunction() {
 }
 
 bool NotificationUpdateFunction::RunImpl() {
   params_ = api::experimental_notification::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
+  if (!IsNotificationApiEnabled()) {
+    SendResponse(false);
+    return true;
+  }
+
   if (g_browser_process->notification_ui_manager()->
       DoesIdExist(NotificationApiDelegate::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;
 }
 
 NotificationDeleteFunction::NotificationDeleteFunction() {
 }
 
 NotificationDeleteFunction::~NotificationDeleteFunction() {
 }
 
 bool NotificationDeleteFunction::RunImpl() {
   params_ = api::experimental_notification::Delete::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
+  if (!IsNotificationApiEnabled()) {
+    SendResponse(false);
+    return true;
+  }
+
   bool cancel_result = g_browser_process->notification_ui_manager()->
       CancelById(NotificationApiDelegate::CreateScopedIdentifier(
           extension_->id(), params_->notification_id));
 
   SetResult(Value::CreateBooleanValue(cancel_result));
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions