Update browserAction.setIcon and pageAction.setIcon for hidpi

chrome/renderer/extensions/set_icon_natives.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/renderer/extensions/set_icon_natives.h"
 
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/extensions/request_sender.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 
+namespace {
+
+const char* kImageSizeKeys[] = { "19", "38" };
+
+}  // namespace
+
 namespace extensions {
 
 SetIconNatives::SetIconNatives(Dispatcher* dispatcher,
                                RequestSender* request_sender)
     : ChromeV8Extension(dispatcher), request_sender_(request_sender) {
   RouteFunction("SetIconCommon",
                 base::Bind(&SetIconNatives::SetIconCommon,
                            base::Unretained(this)));
 }
 
 bool SetIconNatives::ConvertImageDataToBitmapValue(
-    const v8::Arguments& args, Value** bitmap_value) {
-  v8::Local<v8::Object> extension_args = args[1]->ToObject();
-  v8::Local<v8::Object> details =
-      extension_args->Get(v8::String::New("0"))->ToObject();
-  v8::Local<v8::Object> image_data =
-      details->Get(v8::String::New("imageData"))->ToObject();
+    const v8::Local<v8::Object> image_data, Value** bitmap_value) {
   v8::Local<v8::Object> data =
       image_data->Get(v8::String::New("data"))->ToObject();
   int width = image_data->Get(v8::String::New("width"))->Int32Value();
   int height = image_data->Get(v8::String::New("height"))->Int32Value();
 
   int data_length = data->Get(v8::String::New("length"))->Int32Value();
   if (data_length != 4 * width * height) {
     NOTREACHED() << "Invalid argument to setIcon. Expecting ImageData.";
     return false;
   }
@@ skipping 15 matching lines @@
 
   // Construct the Value object.
   IPC::Message bitmap_pickle;
   IPC::WriteParam(&bitmap_pickle, bitmap);
   *bitmap_value = base::BinaryValue::CreateWithCopiedBuffer(
       static_cast<const char*>(bitmap_pickle.data()), bitmap_pickle.size());
 
   return true;
 }
 
+bool SetIconNatives::ConvertImageDataSetToBitmapValueSet(
+    const v8::Arguments& args, DictionaryValue** bitmap_set_value) {
+  v8::Local<v8::Object> extension_args = args[1]->ToObject();
+  v8::Local<v8::Object> details =
+      extension_args->Get(v8::String::New("0"))->ToObject();
+  v8::Local<v8::Object> image_data_set =
+      details->Get(v8::String::New("imageDataSet"))->ToObject();
+
+  *bitmap_set_value = new DictionaryValue();

[Jeffrey Yasskin, 2012/08/17 23:20:28]

This will be a memory leak if the function returns false.

In other codebases, I'd return a scoped_ptr<DictionaryValue>, and use NULL as
the failure value. I'm not sure if that's common practice here.

[tbarzic, 2012/08/21 00:22:07]

Done.

+  for (size_t i = 0; i < arraysize(kImageSizeKeys); i++) {
+    if (!image_data_set->Has(v8::String::New(kImageSizeKeys[i])))
+      continue;
+    v8::Local<v8::Object> image_data =
+        image_data_set->Get(v8::String::New(kImageSizeKeys[i]))->ToObject();
+    Value* image_data_bitmap = NULL;
+    if (!ConvertImageDataToBitmapValue(image_data, &image_data_bitmap))
+      return false;
+    (*bitmap_set_value)->Set(kImageSizeKeys[i], image_data_bitmap);
+  }
+  return true;
+}
+
 v8::Handle<v8::Value> SetIconNatives::SetIconCommon(
     const v8::Arguments& args) {
-  Value* bitmap_value = NULL;
-  if (!ConvertImageDataToBitmapValue(args, &bitmap_value))
+  DictionaryValue* bitmap_set_value = NULL;
+  if (!ConvertImageDataSetToBitmapValueSet(args, &bitmap_set_value))
     return v8::Undefined();
 
   v8::Local<v8::Object> extension_args = args[1]->ToObject();
   v8::Local<v8::Object> details =
       extension_args->Get(v8::String::New("0"))->ToObject();
 
   DictionaryValue* dict = new DictionaryValue();
-  dict->Set("imageData", bitmap_value);
+  dict->Set("imageDataSet", bitmap_set_value);
 
   if (details->Has(v8::String::New("tabId"))) {
     dict->SetInteger("tabId",
                      details->Get(v8::String::New("tabId"))->Int32Value());
   }
 
   ListValue list_value;
   list_value.Append(dict);
 
   std::string name = *v8::String::AsciiValue(args[0]);
   int request_id = args[2]->Int32Value();
   bool has_callback = args[3]->BooleanValue();
   bool for_io_thread = args[4]->BooleanValue();
 
   request_sender_->StartRequest(name,
                                 request_id,
                                 has_callback,
                                 for_io_thread,
                                 &list_value);
   return v8::Undefined();
 }
 
 }  // namespace extensions