Implementation of IDBFactory::getDatabaseNames

content/renderer/indexed_db_dispatcher.cc

 // Copyright (c) 2011 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 "content/renderer/indexed_db_dispatcher.h"
 
 #include "content/common/indexed_db_messages.h"
 #include "content/renderer/render_thread.h"
 #include "content/renderer/render_view.h"
 #include "content/renderer/renderer_webidbcursor_impl.h"
 #include "content/renderer/renderer_webidbdatabase_impl.h"
 #include "content/renderer/renderer_webidbindex_impl.h"
 #include "content/renderer/renderer_webidbobjectstore_impl.h"
 #include "content/renderer/renderer_webidbtransaction_impl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBDatabaseCallbacks.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBDatabaseError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBKeyRange.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSerializedScriptValue.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 
+using WebKit::WebDOMStringList;
 using WebKit::WebExceptionCode;
 using WebKit::WebFrame;
 using WebKit::WebIDBCallbacks;
 using WebKit::WebIDBKeyRange;
 using WebKit::WebIDBDatabase;
 using WebKit::WebIDBDatabaseCallbacks;
 using WebKit::WebIDBDatabaseError;
 using WebKit::WebIDBTransaction;
 using WebKit::WebIDBTransactionCallbacks;
 
 IndexedDBDispatcher::IndexedDBDispatcher() {
 }
 
 IndexedDBDispatcher::~IndexedDBDispatcher() {
 }
 
 bool IndexedDBDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(IndexedDBDispatcher, msg)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIDBCursor,
                         OnSuccessOpenCursor)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIDBDatabase,
                         OnSuccessIDBDatabase)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIndexedDBKey,
                         OnSuccessIndexedDBKey)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIDBTransaction,
                         OnSuccessIDBTransaction)
+    IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessStringList,
+                        OnSuccessStringList)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessSerializedScriptValue,
                         OnSuccessSerializedScriptValue)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksError, OnError)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksBlocked, OnBlocked)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_TransactionCallbacksAbort, OnAbort)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_TransactionCallbacksComplete, OnComplete)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksVersionChange,
                         OnVersionChange)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 55 matching lines @@
     return; // We must be shutting down.
 
   IndexedDBHostMsg_FactoryOpen_Params params;
   params.routing_id = render_view->routing_id();
   params.response_id = pending_callbacks_.Add(callbacks.release());
   params.origin = origin;
   params.name = name;
   RenderThread::current()->Send(new IndexedDBHostMsg_FactoryOpen(params));
 }
 
+void IndexedDBDispatcher::RequestIDBFactoryGetDatabaseNames(
+    WebIDBCallbacks* callbacks_ptr,
+    const string16& origin,
+    WebFrame* web_frame) {
+  scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
+
+  if (!web_frame)
+    return; // We must be shutting down.
+  RenderView* render_view = RenderView::FromWebView(web_frame->view());
+  if (!render_view)
+    return; // We must be shutting down.
+
+  IndexedDBHostMsg_FactoryGetDatabaseNames_Params params;
+  params.routing_id = render_view->routing_id();
+  params.response_id = pending_callbacks_.Add(callbacks.release());
+  params.origin = origin;
+  RenderThread::current()->Send(
+      new IndexedDBHostMsg_FactoryGetDatabaseNames(params));
+}
+
 void IndexedDBDispatcher::RequestIDBFactoryDeleteDatabase(
     const string16& name,
     WebIDBCallbacks* callbacks_ptr,
     const string16& origin,
     WebFrame* web_frame) {
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
   if (!web_frame)
     return; // We must be shutting down.
   RenderView* render_view = RenderView::FromWebView(web_frame->view());
@@ skipping 242 matching lines @@
   pending_callbacks_.Remove(response_id);
 }
 
 void IndexedDBDispatcher::OnSuccessIDBTransaction(int32 response_id,
                                                   int32 object_id) {
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
   callbacks->onSuccess(new RendererWebIDBTransactionImpl(object_id));
   pending_callbacks_.Remove(response_id);
 }
 
+void IndexedDBDispatcher::OnSuccessStringList(
+    int32 response_id, const std::vector<string16>& value) {
+  WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
+  WebDOMStringList string_list;
+  for (std::vector<string16>::const_iterator it = value.begin();
+       it != value.end(); ++it)
+      string_list.append(*it);
+  callbacks->onSuccess(string_list);
+  pending_callbacks_.Remove(response_id);
+}
+
 void IndexedDBDispatcher::OnSuccessSerializedScriptValue(
     int32 response_id, const SerializedScriptValue& value) {
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
   callbacks->onSuccess(value);
   pending_callbacks_.Remove(response_id);
 }
 
 void IndexedDBDispatcher::OnSuccessOpenCursor(int32 repsonse_id,
                                               int32 object_id) {
   WebIDBCallbacks* callbacks =
@@ skipping 30 matching lines @@
 
 void IndexedDBDispatcher::OnVersionChange(int32 database_id,
                                           const string16& newVersion) {
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(database_id);
   // callbacks would be NULL if a versionchange event is received after close
   // has been called.
   if (callbacks)
     callbacks->onVersionChange(newVersion);
 }