Update notifications API after review.

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/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/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 {
 
 const char kResultKey[] = "result";
 
 class NotificationApiDelegate : public NotificationDelegate {
  public:
   NotificationApiDelegate(ApiFunction* api_function,
@@ skipping 79 matching lines @@
 };
 
 }  // namespace
 
 NotificationApiFunction::NotificationApiFunction() {
 }
 
 NotificationApiFunction::~NotificationApiFunction() {
 }
 
+ui::notifications::NotificationType
+NotificationApiFunction::MapApiTemplateTypeToType(
+    api::experimental_notification::TemplateType type) {
+  switch (type) {
+    case api::experimental_notification::TEMPLATE_TYPE_NONE:
+    case api::experimental_notification::TEMPLATE_TYPE_SIMPLE:
+      return ui::notifications::NOTIFICATION_TYPE_SIMPLE;
+    case api::experimental_notification::TEMPLATE_TYPE_BASIC:
+      return ui::notifications::NOTIFICATION_TYPE_BASE_FORMAT;
+    case api::experimental_notification::TEMPLATE_TYPE_IMAGE:
+      return ui::notifications::NOTIFICATION_TYPE_IMAGE;
+    case api::experimental_notification::TEMPLATE_TYPE_LIST:
+      return ui::notifications::NOTIFICATION_TYPE_MULTIPLE;
+    default:
+      // Gracefully handle newer application code that is running on an older
+      // runtime that doesn't recognize the requested template.
+      return ui::notifications::NOTIFICATION_TYPE_SIMPLE;

[dharcourt, 2013/02/06 21:34:20]

Wouldn't NOTIFICATION_TYPE_BASIC be more appropriate for this use case? If the
app code is newer, it's more likely to have notifications based on BASIC than on
SIMPLE (for example 80 pixel icons instead of 40 pixel ones).

+  }
+}
+
 void NotificationApiFunction::CreateNotification(
     const std::string& id,
     api::experimental_notification::NotificationOptions* options) {
-  ui::notifications::NotificationType type =
-      ui::notifications::StringToNotificationType(options->type);
+  ui::notifications::NotificationType type = MapApiTemplateTypeToType(
+      options->template_type);
   GURL icon_url(UTF8ToUTF16(options->icon_url));
   string16 title(UTF8ToUTF16(options->title));
   string16 message(UTF8ToUTF16(options->message));
 
   scoped_ptr<DictionaryValue> optional_fields(new DictionaryValue());
 
   // For all notification types.
   if (options->priority.get())
     optional_fields->SetInteger(ui::notifications::kPriorityKey,
                                 *options->priority);
-  if (options->timestamp.get())
+  if (options->event_time.get())
     optional_fields->SetString(ui::notifications::kTimestampKey,
-                               *options->timestamp);
-  if (options->unread_count.get())
-    optional_fields->SetInteger(ui::notifications::kUnreadCountKey,
-                                *options->unread_count);
-  if (options->button_one_title.get())
-    optional_fields->SetString(ui::notifications::kButtonOneTitleKey,
-                               UTF8ToUTF16(*options->button_one_title));
-  if (options->button_one_icon_url.get())
-    optional_fields->SetString(ui::notifications::kButtonOneIconUrlKey,
-                               UTF8ToUTF16(*options->button_one_icon_url));
-  // TODO(dharcourt): Fail if:
-  //  (options->button_two_title.get() || options->button_two_icon_url.get()) &&
-  //  !(options->button_one_title.get() || options->button_one_icon_url.get())
-  if (options->button_two_title.get())
-    optional_fields->SetString(ui::notifications::kButtonTwoTitleKey,
-                               UTF8ToUTF16(*options->button_two_title));
-  if (options->button_two_icon_url.get())
-    optional_fields->SetString(ui::notifications::kButtonTwoIconUrlKey,
-                               UTF8ToUTF16(*options->button_two_icon_url));
+                               *options->event_time);
+  if (options->buttons.get()) {
+    if (options->buttons->size() > 0) {
+      linked_ptr<api::experimental_notification::NotificationButton> button =
+          (*options->buttons)[0];
+      optional_fields->SetString(ui::notifications::kButtonOneTitleKey,
+                                 UTF8ToUTF16(button->title));
+      if (button->icon_url.get())
+        optional_fields->SetString(ui::notifications::kButtonOneIconUrlKey,
+                                   UTF8ToUTF16(*button->icon_url));
+    }
+    if (options->buttons->size() > 1) {
+      linked_ptr<api::experimental_notification::NotificationButton> button =
+          (*options->buttons)[1];
+      optional_fields->SetString(ui::notifications::kButtonTwoTitleKey,
+                                 UTF8ToUTF16(button->title));
+      if (button->icon_url.get())
+        optional_fields->SetString(ui::notifications::kButtonTwoIconUrlKey,
+                                   UTF8ToUTF16(*button->icon_url));
+    }
+  }
   if (options->expanded_message.get())
     optional_fields->SetString(ui::notifications::kExpandedMessageKey,
                                UTF8ToUTF16(*options->expanded_message));
 
   // For image notifications (type == 'image').
   // TODO(dharcourt): Fail if (type == 'image' && !options->image_url.get())
   // TODO(dharcourt): Fail if (type != 'image' && options->image_url.get())
   if (options->image_url.get())
     optional_fields->SetString(ui::notifications::kImageUrlKey,
                                UTF8ToUTF16(*options->image_url));
@@ skipping 103 matching lines @@
       CancelById(NotificationApiDelegate::CreateScopedIdentifier(
           extension_->id(), params_->notification_id));
 
   SetResult(Value::CreateBooleanValue(cancel_result));
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions