Use a two-part data format version in IndexedDB metadata.

content/browser/indexed_db/indexed_db_dispatcher_host.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 "content/browser/indexed_db/indexed_db_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
@@ skipping 77 matching lines @@
     return;
   }
 
   DCHECK_GE(iter->second.second, 1);
   if (iter->second.second == 1)
     blob_data_handle_map_.erase(iter);
   else
     --iter->second.second;
 }
 
+void IndexedDBDispatcherHost::Configure(
+    const IndexedDBDataFormatVersion& client_data_format_version) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  // TODO(jbroman): We could take mojo::GetBadMessageCallback here to tell the

[jsbell, 2017/04/04 19:24:33]

If this is happening w/in dispatch, we should be able to call
mojo::ReportBadMessage() directly.

Here's an idea for error handling:

* Change client_data_format_version_ to be used only on BrowserThread::IO
* Check version here, and call mojo::ReportBadMessage()/early return if changed.
* Check in GetDatabaseNames/Open/DeleteDatabase (the non-OnIDBThread versions)
and call mojo::ReportBadMessage()/early return if not set.
* Pass the version through to the *OnIDBThread methods as a new argument.

+  // IPC system that this is a bad message, if this ever changes. Should we?
+  indexed_db_context_->TaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&IndexedDBDispatcherHost::ConfigureOnIDBThread,
+                            this, client_data_format_version));
+}
+
 void IndexedDBDispatcherHost::GetDatabaseNames(
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info,
     const url::Origin& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsValidOrigin(origin)) {
     mojo::ReportBadMessage(kInvalidOrigin);
     return;
   }
 
@@ skipping 44 matching lines @@
   }
 
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(this, origin, std::move(callbacks_info)));
   indexed_db_context_->TaskRunner()->PostTask(
       FROM_HERE, base::Bind(&IndexedDBDispatcherHost::DeleteDatabaseOnIDBThread,
                             this, base::Passed(&callbacks), origin, name,
                             force_close));
 }
 
+void IndexedDBDispatcherHost::ConfigureOnIDBThread(
+    const IndexedDBDataFormatVersion& client_data_format_version) {
+  if (!client_data_format_version_)

[dcheng, 2017/04/04 19:59:21]

Since this is coming from the renderer, we do need to check that the specified
values are legal (e.g. both v8 version and blink version are <=
std::numeric_limits<int32_t>::max()).

But I think I would strongly prefer it if we could someone make this
compile-time...

+    client_data_format_version_ = client_data_format_version;
+  if (client_data_format_version_ != client_data_format_version)
+    LOG(ERROR) << "IndexedDB client's supported data format version changed!";

[dcheng, 2017/04/04 19:59:21]

Nit: DLOG instead of LOG? I don't think this will be helpful to people that
aren't developers.

+}
+
 void IndexedDBDispatcherHost::GetDatabaseNamesOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const url::Origin& origin) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
+  // TODO(jbroman): How fail here?
+  if (!client_data_format_version_)
+    LOG(ERROR) << "IndexedDB client failed to call Configure!";
+
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
   context()->GetIDBFactory()->GetDatabaseNames(
-      callbacks, origin, indexed_db_path, request_context_getter_);
+      callbacks, origin, indexed_db_path,
+      client_data_format_version_.value_or(IndexedDBDataFormatVersion()),
+      request_context_getter_);
 }
 
 void IndexedDBDispatcherHost::OpenOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     const url::Origin& origin,
     const base::string16& name,
     int64_t version,
     int64_t transaction_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
+  // TODO(jbroman): How fail here?
+  if (!client_data_format_version_)
+    LOG(ERROR) << "IndexedDB client failed to call Configure!";
+
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   callbacks->SetConnectionOpenStartTime(begin_time);
   std::unique_ptr<IndexedDBPendingConnection> connection =
       base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, database_callbacks, ipc_process_id_, transaction_id,
           version);
   DCHECK(request_context_getter_);
-  context()->GetIDBFactory()->Open(name, std::move(connection),
-                                   request_context_getter_, origin,
-                                   indexed_db_path);
+  context()->GetIDBFactory()->Open(
+      name, std::move(connection), request_context_getter_, origin,
+      indexed_db_path,
+      client_data_format_version_.value_or(IndexedDBDataFormatVersion()));
 }
 
 void IndexedDBDispatcherHost::DeleteDatabaseOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const url::Origin& origin,
     const base::string16& name,
     bool force_close) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
+
+  // TODO(jbroman): How fail here?
+  if (!client_data_format_version_)
+    LOG(ERROR) << "IndexedDB client failed to call Configure!";
+
   DCHECK(request_context_getter_);
   context()->GetIDBFactory()->DeleteDatabase(
       name, request_context_getter_, callbacks, origin, indexed_db_path,
+      client_data_format_version_.value_or(IndexedDBDataFormatVersion()),
       force_close);
 }
 
 }  // namespace content