Remove the notificationProvider extension API

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 <stddef.h>
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/notification.h"
-#include "chrome/browser/notifications/notification_conversion_helper.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/notifications/notifier_state_tracker.h"
 #include "chrome/browser/notifications/notifier_state_tracker_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/notifications/notification_style.h"
 #include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
 #include "components/keyed_service/core/keyed_service_shutdown_notifier.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/features/feature.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_rep.h"
+#include "ui/gfx/skia_util.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/notifier_settings.h"
 #include "url/gurl.h"
 
 using message_center::NotifierId;
 
 namespace extensions {
 
 namespace notifications = api::notifications;
 
@@ skipping 59 matching lines @@
       width, height, message_center::kSmallImageMaskBackgroundColor);
   // Foreground color white
   const gfx::ImageSkia foreground = CreateSolidColorImage(
       width, height, message_center::kSmallImageMaskForegroundColor);
   const gfx::ImageSkia masked_small_image =
       gfx::ImageSkiaOperations::CreateMaskedImage(foreground, small_image);
   return gfx::Image(gfx::ImageSkiaOperations::CreateSuperimposedImage(
       background, masked_small_image));
 }
 
+// Converts the |notification_bitmap| (in RGBA format) to the |*return_image|
+// (which is in ARGB format).
+bool NotificationBitmapToGfxImage(
+    float max_scale,
+    const gfx::Size& target_size_dips,
+    const notifications::NotificationBitmap& notification_bitmap,
+    gfx::Image* return_image) {
+  const int max_device_pixel_width = target_size_dips.width() * max_scale;
+  const int max_device_pixel_height = target_size_dips.height() * max_scale;
+
+  const int kBytesPerPixel = 4;
+
+  const int width = notification_bitmap.width;
+  const int height = notification_bitmap.height;
+
+  if (width < 0 || height < 0 || width > max_device_pixel_width ||
+      height > max_device_pixel_height)
+    return false;
+
+  // Ensure we have rgba data.
+  std::vector<char>* rgba_data = notification_bitmap.data.get();
+  if (!rgba_data)
+    return false;
+
+  const size_t rgba_data_length = rgba_data->size();
+  const size_t rgba_area = width * height;
+
+  if (rgba_data_length != rgba_area * kBytesPerPixel)
+    return false;
+
+  SkBitmap bitmap;
+  // Allocate the actual backing store with the sanitized dimensions.
+  if (!bitmap.tryAllocN32Pixels(width, height))
+    return false;
+
+  // Ensure that our bitmap and our data now refer to the same number of pixels.
+  if (rgba_data_length != bitmap.getSafeSize())
+    return false;
+
+  uint32_t* pixels = bitmap.getAddr32(0, 0);
+  const char* c_rgba_data = rgba_data->data();
+
+  for (size_t t = 0; t < rgba_area; ++t) {
+    // |c_rgba_data| is RGBA, pixels is ARGB.
+    size_t rgba_index = t * kBytesPerPixel;
+    pixels[t] =
+        SkPreMultiplyColor(((c_rgba_data[rgba_index + 3] & 0xFF) << 24) |
+                           ((c_rgba_data[rgba_index + 0] & 0xFF) << 16) |
+                           ((c_rgba_data[rgba_index + 1] & 0xFF) << 8) |
+                           ((c_rgba_data[rgba_index + 2] & 0xFF) << 0));
+  }
+
+  // TODO(dewittj): Handle HiDPI images with more than one scale factor
+  // representation.
+  gfx::ImageSkia skia(gfx::ImageSkiaRep(bitmap, 1.0f));
+  *return_image = gfx::Image(skia);
+  return true;
+}
+
 class ShutdownNotifierFactory
     : public BrowserContextKeyedServiceShutdownNotifierFactory {
  public:
   static ShutdownNotifierFactory* GetInstance() {
     return base::Singleton<ShutdownNotifierFactory>::get();
   }
 
  private:
   friend struct base::DefaultSingletonTraits<ShutdownNotifierFactory>;
 
@@ skipping 177 matching lines @@
   message_center::NotificationType type =
       MapApiTemplateTypeToType(options->type);
   UMA_HISTOGRAM_ENUMERATION("Notifications.ExtensionNotificationType", type,
                             message_center::NOTIFICATION_TYPE_LAST);
 
   const base::string16 title(base::UTF8ToUTF16(*options->title));
   const base::string16 message(base::UTF8ToUTF16(*options->message));
   gfx::Image icon;
 
   if (!options->icon_bitmap.get() ||
-      !NotificationConversionHelper::NotificationBitmapToGfxImage(
+      !NotificationBitmapToGfxImage(
           image_scale, bitmap_sizes.icon_size, *options->icon_bitmap, &icon)) {
     SetError(kUnableToDecodeIconError);
     return false;
   }
 
   // Then, handle any optional data that's been provided.
   message_center::RichNotificationData optional_fields;
   if (options->app_icon_mask_url.get()) {
     gfx::Image small_icon_mask;
-    if (!NotificationConversionHelper::NotificationBitmapToGfxImage(
+    if (!NotificationBitmapToGfxImage(
             image_scale, bitmap_sizes.app_icon_mask_size,
             *options->app_icon_mask_bitmap, &small_icon_mask)) {
       SetError(kUnableToDecodeIconError);
       return false;
     }
     optional_fields.small_image =
         GetMaskedSmallImage(small_icon_mask.AsImageSkia());
   }
 
   if (options->priority.get())
@@ skipping 13 matching lines @@
                               number_of_buttons, 17);
 
     number_of_buttons = number_of_buttons > 2 ? 2 : number_of_buttons;
 
     for (size_t i = 0; i < number_of_buttons; i++) {
       message_center::ButtonInfo info(
           base::UTF8ToUTF16((*options->buttons)[i].title));
       extensions::api::notifications::NotificationBitmap* icon_bitmap_ptr =
           (*options->buttons)[i].icon_bitmap.get();
       if (icon_bitmap_ptr) {
-        NotificationConversionHelper::NotificationBitmapToGfxImage(
+        NotificationBitmapToGfxImage(
             image_scale, bitmap_sizes.button_icon_size, *icon_bitmap_ptr,
             &info.icon);
       }
       optional_fields.buttons.push_back(info);
     }
   }
 
   if (options->context_message) {
     optional_fields.context_message =
         base::UTF8ToUTF16(*options->context_message);
   }
 
   bool has_image = options->image_bitmap.get() &&
-                   NotificationConversionHelper::NotificationBitmapToGfxImage(
+                   NotificationBitmapToGfxImage(
                        image_scale, bitmap_sizes.image_size,
                        *options->image_bitmap, &optional_fields.image);
 
   // We should have an image if and only if the type is an image type.
   if (has_image != (type == message_center::NOTIFICATION_TYPE_IMAGE)) {
     SetError(kExtraImageProvided);
     return false;
   }
 
   // We should have list items if and only if the type is a multiple type.
@@ skipping 66 matching lines @@
   // Update optional fields if provided.
   if (options->type != api::notifications::TEMPLATE_TYPE_NONE)
     notification->set_type(MapApiTemplateTypeToType(options->type));
   if (options->title)
     notification->set_title(base::UTF8ToUTF16(*options->title));
   if (options->message)
     notification->set_message(base::UTF8ToUTF16(*options->message));
 
   if (options->icon_bitmap.get()) {
     gfx::Image icon;
-    if (!NotificationConversionHelper::NotificationBitmapToGfxImage(
+    if (!NotificationBitmapToGfxImage(
             image_scale, bitmap_sizes.icon_size, *options->icon_bitmap,
             &icon)) {
       SetError(kUnableToDecodeIconError);
       return false;
     }
     notification->set_icon(icon);
   }
 
   if (options->app_icon_mask_bitmap.get()) {
     gfx::Image app_icon_mask;
-    if (!NotificationConversionHelper::NotificationBitmapToGfxImage(
+    if (!NotificationBitmapToGfxImage(
             image_scale, bitmap_sizes.app_icon_mask_size,
             *options->app_icon_mask_bitmap, &app_icon_mask)) {
       SetError(kUnableToDecodeIconError);
       return false;
     }
     notification->set_small_image(
         GetMaskedSmallImage(app_icon_mask.AsImageSkia()));
   }
 
   if (options->priority)
     notification->set_priority(*options->priority);
 
   if (options->event_time)
     notification->set_timestamp(base::Time::FromJsTime(*options->event_time));
 
   if (options->buttons) {
     // Currently we allow up to 2 buttons.
     size_t number_of_buttons = options->buttons->size();
     number_of_buttons = number_of_buttons > 2 ? 2 : number_of_buttons;
 
     std::vector<message_center::ButtonInfo> buttons;
     for (size_t i = 0; i < number_of_buttons; i++) {
       message_center::ButtonInfo button(
           base::UTF8ToUTF16((*options->buttons)[i].title));
       extensions::api::notifications::NotificationBitmap* icon_bitmap_ptr =
           (*options->buttons)[i].icon_bitmap.get();
       if (icon_bitmap_ptr) {
-        NotificationConversionHelper::NotificationBitmapToGfxImage(
+        NotificationBitmapToGfxImage(
             image_scale, bitmap_sizes.button_icon_size, *icon_bitmap_ptr,
             &button.icon);
       }
       buttons.push_back(button);
     }
     notification->set_buttons(buttons);
   }
 
   if (options->context_message) {
     notification->set_context_message(
         base::UTF8ToUTF16(*options->context_message));
   }
 
   gfx::Image image;
   bool has_image =
       options->image_bitmap.get() &&
-      NotificationConversionHelper::NotificationBitmapToGfxImage(
+      NotificationBitmapToGfxImage(
           image_scale, bitmap_sizes.image_size, *options->image_bitmap, &image);
 
   if (has_image) {
     // We should have an image if and only if the type is an image type.
     if (notification->type() != message_center::NOTIFICATION_TYPE_IMAGE) {
       SetError(kExtraImageProvided);
       return false;
     }
     notification->set_image(image);
   }
@@ skipping 223 matching lines @@
           : api::notifications::PERMISSION_LEVEL_DENIED;
 
   SetResult(base::MakeUnique<base::StringValue>(
       api::notifications::ToString(result)));
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions