Fix IndexedDB race condition during shutdown.

chrome/browser/in_process_webkit/indexed_db_key_utility_client.h

 // 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.
 
 #ifndef CHROME_BROWSER_IN_PROCESS_WEBKIT_INDEXED_DB_KEY_UTILITY_CLIENT_H_
 #define CHROME_BROWSER_IN_PROCESS_WEBKIT_INDEXED_DB_KEY_UTILITY_CLIENT_H_
 #pragma once
 
 #include "base/ref_counted.h"
+#include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/utility_process_host.h"
 
 class IndexedDBKey;
 class SerializedScriptValue;
 
 // This class is responsible to obtain IndexedDBKeys from the
 // SerializedScriptValues given an IDBKeyPath. It uses UtilityProcess to do this
 // inside a sandbox (a V8 lock is required there). At this level, all methods
 // are synchronous as required by the caller. The public API is used on
 // WEBKIT thread, but internally it moves around to UI and IO as needed.
 class IndexedDBKeyUtilityClient
     : public base::RefCountedThreadSafe<IndexedDBKeyUtilityClient> {
  public:
-  IndexedDBKeyUtilityClient();
 
-  // Starts the UtilityProcess. Must be called before any other method.
-  void StartUtilityProcess();
+  // Get a pointer to the IndexedDBKeyUtilityClient instance.
+  static IndexedDBKeyUtilityClient* Get();
 
-  // Ends the UtilityProcess. Must be called after StartUtilityProcess() and
-  // before destruction.
-  // TODO(bulach): figure out an appropriate hook so that we can keep the
-  // UtilityProcess running for a longer period of time and avoid spinning it
-  // on every IDBObjectStore::Put call.
-  void EndUtilityProcess();
+  // Shut down the IndexedDBKeyUtilityClient if it was ever started.
+  static void Shutdown();
 
   // Synchronously obtain the |keys| from |values| for the given |key_path|.
   void CreateIDBKeysFromSerializedValuesAndKeyPath(
       const std::vector<SerializedScriptValue>& values,
       const string16& key_path,
       std::vector<IndexedDBKey>* keys);
 
  private:
   class Client : public UtilityProcessHost::Client {
    public:
     explicit Client(IndexedDBKeyUtilityClient* parent);
 
     // UtilityProcessHost::Client
     virtual void OnProcessCrashed(int exit_code);
     virtual void OnIDBKeysFromValuesAndKeyPathSucceeded(
         int id, const std::vector<IndexedDBKey>& keys);
     virtual void OnIDBKeysFromValuesAndKeyPathFailed(int id);
 
    private:
     IndexedDBKeyUtilityClient* parent_;
 
     DISALLOW_COPY_AND_ASSIGN(Client);
   };
 
   friend class base::RefCountedThreadSafe<IndexedDBKeyUtilityClient>;
+  IndexedDBKeyUtilityClient();
   ~IndexedDBKeyUtilityClient();
 
+  // Lock to protect the instance_ member.
+  static base::Lock instantiation_lock_;
+  static scoped_refptr<IndexedDBKeyUtilityClient> instance_;

[bulach, 2011/01/14 17:55:08]

iirc, it's not safe / advisable to have non-POD static, and valgrind may
complain about them too..
would it be possible to wrap this all up in base::Singleton instead? (as in,
have a singleton that owns this class, possibly move it to the cc file, and
expose just GetInstance, CreateIDBKeys and Shutdown..)

+
+  // Starts the UtilityProcess. Must be called before any other method.
+  void StartUtilityProcess();
+
   void GetRDHAndStartUtilityProcess();
   void StartUtilityProcessInternal(ResourceDispatcherHost* rdh);
   void EndUtilityProcessInternal();
   void CallStartIDBKeyFromValueAndKeyPathFromIOThread(
       const std::vector<SerializedScriptValue>& values,
       const string16& key_path);
 
   void SetKeys(const std::vector<IndexedDBKey>& keys);
   void FinishCreatingKeys();
 
@@ skipping 11 matching lines @@
   std::vector<IndexedDBKey> keys_;
 
   // Used in the IO thread.
   UtilityProcessHost* utility_process_host_;
   scoped_refptr<Client> client_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBKeyUtilityClient);
 };
 
 #endif  // CHROME_BROWSER_IN_PROCESS_WEBKIT_INDEXED_DB_KEY_UTILITY_CLIENT_H_