Support PNG and quality control in chrome.tabs.captureVisibleTab().

chrome/browser/extensions/extension_tabs_module.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/extension_tabs_module.h"
 
 #include "base/histogram.h"
 #include "base/base64.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/window_sizer.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/url_constants.h"
 #include "gfx/codec/jpeg_codec.h"
+#include "gfx/codec/png_codec.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace keys = extension_tabs_module_constants;
 
+const int CaptureVisibleTabFunction::kDefaultQuality = 90;
+
 // Forward declare static helper functions defined below.
 
 // |error_message| can optionally be passed in a will be set with an appropriate
 // message if the window cannot be found by id.
 static Browser* GetBrowserInProfileWithId(Profile* profile,
                                           const int window_id,
                                           bool include_incognito,
                                           std::string* error_message);
 
 // |error_message| can optionally be passed in and will be set with an
@@ skipping 754 matching lines @@
   RenderViewHost* render_view_host = contents->render_view_host();
   render_view_host->delegate()->Close(render_view_host);
   return true;
 }
 
 bool CaptureVisibleTabFunction::RunImpl() {
   Browser* browser;
   // windowId defaults to "current" window.
   int window_id = -1;
 
-  if (!args_->IsType(Value::TYPE_NULL)) {
-    EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&window_id));
+  EXTENSION_FUNCTION_VALIDATE(args_->IsType(Value::TYPE_LIST));
+  const ListValue* args = args_as_list();
+
+  if (HasOptionalArgument(0)) {
+    EXTENSION_FUNCTION_VALIDATE(args->GetInteger(0, &window_id));
     browser = GetBrowserInProfileWithId(profile(), window_id,
                                         include_incognito(), &error_);
   } else {
     browser = GetCurrentBrowser();
   }
 
   if (!browser) {
     error_ = keys::kNoCurrentWindowError;
     return false;
   }
 
+  image_format_ = FORMAT_JPEG;  // Default format is JPEG.
+  image_quality_ = kDefaultQuality;  // Default quality setting.
+
+  if (HasOptionalArgument(1)) {
+    DictionaryValue* options;
+    EXTENSION_FUNCTION_VALIDATE(args->GetDictionary(1, &options));
+
+    if (options->HasKey(keys::kFormatKey)) {
+      std::string format;
+      EXTENSION_FUNCTION_VALIDATE(
+          options->GetString(keys::kFormatKey, &format));
+
+      if (format == keys::kFormatValueJpeg) {
+        image_format_ = FORMAT_JPEG;
+      } else if (format == keys::kFormatValuePng) {
+        image_format_ = FORMAT_PNG;
+      } else {
+        // Schema validation should make this unreachable.
+        EXTENSION_FUNCTION_VALIDATE(0);
+      }
+    }
+
+    if (options->HasKey(keys::kQualityKey)) {
+      EXTENSION_FUNCTION_VALIDATE(
+          options->GetInteger(keys::kQualityKey, &image_quality_));
+    }
+  }
+
   TabContents* tab_contents = browser->GetSelectedTabContents();
   if (!tab_contents) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return false;
   }
   RenderViewHost* render_view_host = tab_contents->render_view_host();
 
   // If a backing store is cached for the tab we want to capture,
   // and it can be copied into a bitmap, then use it to generate the image.
   BackingStore* backing_store = render_view_host->GetBackingStore(false);
@@ skipping 46 matching lines @@
     SendResultFromBitmap(*screen_capture);
   }
 
   Release();  // Balanced in CaptureVisibleTabFunction::RunImpl().
 }
 
 // Turn a bitmap of the screen into an image, set that image as the result,
 // and call SendResponse().
 void CaptureVisibleTabFunction::SendResultFromBitmap(
     const SkBitmap& screen_capture) {
-  scoped_refptr<RefCountedBytes> jpeg_data(new RefCountedBytes);
+  scoped_refptr<RefCountedBytes> image_data(new RefCountedBytes);
   SkAutoLockPixels screen_capture_lock(screen_capture);
-  bool encoded = gfx::JPEGCodec::Encode(
-      reinterpret_cast<unsigned char*>(screen_capture.getAddr32(0, 0)),
-      gfx::JPEGCodec::FORMAT_BGRA, screen_capture.width(),
-      screen_capture.height(),
-      static_cast<int>(screen_capture.rowBytes()), 90,
-      &jpeg_data->data);
+  bool encoded;
+  std::string mime_type;
+  switch (image_format_) {
+    case FORMAT_JPEG:
+      encoded = gfx::JPEGCodec::Encode(
+          reinterpret_cast<unsigned char*>(screen_capture.getAddr32(0, 0)),
+          gfx::JPEGCodec::FORMAT_BGRA,
+          screen_capture.width(),
+          screen_capture.height(),
+          static_cast<int>(screen_capture.rowBytes()), image_quality_,
+          &image_data->data);
+      mime_type = keys::kMimeTypeJpeg;
+      break;
+    case FORMAT_PNG:
+      encoded = gfx::PNGCodec::Encode(
+          reinterpret_cast<unsigned char*>(screen_capture.getAddr32(0, 0)),
+          gfx::PNGCodec::FORMAT_BGRA,
+          screen_capture.width(),
+          screen_capture.height(),
+          static_cast<int>(screen_capture.rowBytes()), false,
+          &image_data->data);
+      mime_type = keys::kMimeTypePng;
+      break;
+    default:
+      NOTREACHED() << "Invalid image format.";
+  }
+
   if (!encoded) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kInternalVisibleTabCaptureError, "");
     SendResponse(false);
     return;
   }
 
   std::string base64_result;
   std::string stream_as_string;
-  stream_as_string.resize(jpeg_data->data.size());
+  stream_as_string.resize(image_data->data.size());
   memcpy(&stream_as_string[0],
-      reinterpret_cast<const char*>(&jpeg_data->data[0]),
-      jpeg_data->data.size());
+      reinterpret_cast<const char*>(&image_data->data[0]),
+      image_data->data.size());
 
   base::Base64Encode(stream_as_string, &base64_result);
-  base64_result.insert(0, "data:image/jpg;base64,");
+  base64_result.insert(0, StringPrintf("data:%s;base64,", mime_type.c_str()));
   result_.reset(new StringValue(base64_result));
   SendResponse(true);
 }
 
 bool DetectTabLanguageFunction::RunImpl() {
   int tab_id = 0;
   Browser* browser = NULL;
   TabContents* contents = NULL;
 
   // If |tab_id| is specified, look for it. Otherwise default to selected tab
@@ skipping 143 matching lines @@
     // caller.
     use_type = url.is_valid() && (url != resolved_url) ?
         RELATIVE_URL_RESOLUTIONS_DIFFER : RELATIVE_URL_RESOLUTIONS_AGREE;
   }
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.APIUse_RelativeURL", use_type,
       EXTENSION_API_RELATIVE_URL_USE_MAX_VALUE);
 
   return url;
 }
-