Adds IDBKeyPath parser / extractor, and provides a mechanism to call it sandboxed.

chrome/utility/utility_thread.cc

 // Copyright (c) 2009 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/utility/utility_thread.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #if defined(OS_WIN)
 #include "base/iat_patch.h"
 #endif
 #include "base/path_service.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_unpacker.h"
 #include "chrome/common/extensions/update_manifest.h"
+#include "chrome/common/indexed_db_key.h"
 #include "chrome/common/utility_messages.h"
 #include "chrome/common/web_resource/web_resource_unpacker.h"
 #include "gfx/rect.h"
 #include "printing/native_metafile.h"
 #include "printing/page_range.h"
 #include "printing/units.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "webkit/glue/idb_bindings.h"
 #include "webkit/glue/image_decoder.h"
 
 
-UtilityThread::UtilityThread() {
+namespace {
+
+template<typename SRC, typename DEST>
+void ConvertVector(const SRC& src, DEST* dest) {
+  dest->reserve(src.size());
+  for (typename SRC::const_iterator i = src.begin(); i != src.end(); ++i)
+    dest->push_back(typename DEST::value_type(*i));
+}
+
+}  // namespace
+
+
+UtilityThread::UtilityThread()
+    : batch_mode_(false) {
   ChildProcess::current()->AddRefProcess();
 }
 
 UtilityThread::~UtilityThread() {
 }
 
 void UtilityThread::OnControlMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(UtilityThread, msg)
     IPC_MESSAGE_HANDLER(UtilityMsg_UnpackExtension, OnUnpackExtension)
     IPC_MESSAGE_HANDLER(UtilityMsg_UnpackWebResource, OnUnpackWebResource)
     IPC_MESSAGE_HANDLER(UtilityMsg_ParseUpdateManifest, OnParseUpdateManifest)
     IPC_MESSAGE_HANDLER(UtilityMsg_DecodeImage, OnDecodeImage)
     IPC_MESSAGE_HANDLER(UtilityMsg_RenderPDFPagesToMetafile,
                         OnRenderPDFPagesToMetafile)
+    IPC_MESSAGE_HANDLER(UtilityMsg_IDBKeysFromValuesAndKeyPath,
+                        OnIDBKeysFromValuesAndKeyPath)
+    IPC_MESSAGE_HANDLER(UtilityMsg_BatchMode_Started, OnBatchModeStarted)
+    IPC_MESSAGE_HANDLER(UtilityMsg_BatchMode_Finished, OnBatchModeFinished)
   IPC_END_MESSAGE_MAP()
 }
 
 void UtilityThread::OnUnpackExtension(const FilePath& extension_path) {
   ExtensionUnpacker unpacker(extension_path);
   if (unpacker.Run() && unpacker.DumpImagesToFile() &&
       unpacker.DumpMessageCatalogsToFile()) {
     Send(new UtilityHostMsg_UnpackExtension_Succeeded(
        *unpacker.parsed_manifest()));
   } else {
     Send(new UtilityHostMsg_UnpackExtension_Failed(unpacker.error_message()));
   }
 
-  ChildProcess::current()->ReleaseProcess();
+  ReleaseProcessIfNeeded();
 }
 
 void UtilityThread::OnUnpackWebResource(const std::string& resource_data) {
   // Parse json data.
   // TODO(mrc): Add the possibility of a template that controls parsing, and
   // the ability to download and verify images.
   WebResourceUnpacker unpacker(resource_data);
   if (unpacker.Run()) {
     Send(new UtilityHostMsg_UnpackWebResource_Succeeded(
         *unpacker.parsed_json()));
   } else {
     Send(new UtilityHostMsg_UnpackWebResource_Failed(
         unpacker.error_message()));
   }
 
-  ChildProcess::current()->ReleaseProcess();
+  ReleaseProcessIfNeeded();
 }
 
 void UtilityThread::OnParseUpdateManifest(const std::string& xml) {
   UpdateManifest manifest;
   if (!manifest.Parse(xml)) {
     Send(new UtilityHostMsg_ParseUpdateManifest_Failed(manifest.errors()));
   } else {
     Send(new UtilityHostMsg_ParseUpdateManifest_Succeeded(manifest.results()));
   }
-  ChildProcess::current()->ReleaseProcess();
+  ReleaseProcessIfNeeded();
 }
 
 void UtilityThread::OnDecodeImage(
     const std::vector<unsigned char>& encoded_data) {
   webkit_glue::ImageDecoder decoder;
   const SkBitmap& decoded_image = decoder.Decode(&encoded_data[0],
                                                  encoded_data.size());
   if (decoded_image.empty()) {
     Send(new UtilityHostMsg_DecodeImage_Failed());
   } else {
     Send(new UtilityHostMsg_DecodeImage_Succeeded(decoded_image));
   }
-  ChildProcess::current()->ReleaseProcess();
+  ReleaseProcessIfNeeded();
 }
 
 
 void UtilityThread::OnRenderPDFPagesToMetafile(
     base::PlatformFile pdf_file,
     const gfx::Rect& render_area,
     int render_dpi,
     const std::vector<printing::PageRange>& page_ranges) {
   bool succeeded = false;
 #if defined(OS_WIN)
   printing::NativeMetafile metafile;
   int highest_rendered_page_number = 0;
   succeeded = RenderPDFToWinMetafile(pdf_file, render_area, render_dpi,
                                      page_ranges, &metafile,
                                      &highest_rendered_page_number);
   if (succeeded) {
     Send(new UtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(metafile,
         highest_rendered_page_number));
   }
 #endif  // defined(OS_WIN)
   if (!succeeded) {
     Send(new UtilityHostMsg_RenderPDFPagesToMetafile_Failed());
   }
-  ChildProcess::current()->ReleaseProcess();
+  ReleaseProcessIfNeeded();
 }
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
 typedef bool (*RenderPDFPageToDCProc)(
     const unsigned char* pdf_buffer, int buffer_size, int page_number, HDC dc,
     int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y,
     int bounds_width, int bounds_height, bool fit_to_bounds,
     bool stretch_to_bounds, bool keep_aspect_ratio, bool center_in_bounds);
 
@@ skipping 116 matching lines @@
         if (*highest_rendered_page_number < page_number)
           *highest_rendered_page_number = page_number;
         ret = true;
       metafile->EndPage();
     }
   }
   metafile->CloseDc();
   return ret;
 }
 #endif  // defined(OS_WIN)
+
+void UtilityThread::OnIDBKeysFromValuesAndKeyPath(
+    int id,
+    const std::vector<SerializedScriptValue>& serialized_script_values,
+    const string16& idb_key_path) {
+  std::vector<WebKit::WebSerializedScriptValue> web_values;
+  ConvertVector(serialized_script_values, &web_values);
+  std::vector<WebKit::WebIDBKey> web_keys;
+  bool error = webkit_glue::IDBKeysFromValuesAndKeyPath(
+      web_values, idb_key_path, &web_keys);
+  if (error) {
+    Send(new UtilityHostMsg_IDBKeysFromValuesAndKeyPath_Failed(id));
+    return;
+  }
+  std::vector<IndexedDBKey> keys;
+  ConvertVector(web_keys, &keys);
+  Send(new UtilityHostMsg_IDBKeysFromValuesAndKeyPath_Succeeded(id, keys));
+  ReleaseProcessIfNeeded();
+}
+
+void UtilityThread::OnBatchModeStarted() {
+  batch_mode_ = true;
+}
+
+void UtilityThread::OnBatchModeFinished() {
+  ChildProcess::current()->ReleaseProcess();
+}
+
+void UtilityThread::ReleaseProcessIfNeeded() {
+  if (!batch_mode_)
+    ChildProcess::current()->ReleaseProcess();
+}