Replace c/b/nss_context by a KeyedService.

components/cert_database/public/cert_database_service_io_part.h

Index: components/cert_database/public/cert_database_service_io_part.h
diff --git a/components/cert_database/public/cert_database_service_io_part.h b/components/cert_database/public/cert_database_service_io_part.h
new file mode 100644
index 0000000000000000000000000000000000000000..14f5336805640e523330661a5c3b3b9dd9309e6f
--- /dev/null
+++ b/components/cert_database/public/cert_database_service_io_part.h
@@ -0,0 +1,61 @@
+// Copyright 2014 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 COMPONENTS_CERT_DATABASE_PUBLIC_CERT_DATABASE_SERVICE_IO_PART_H_
+#define COMPONENTS_CERT_DATABASE_PUBLIC_CERT_DATABASE_SERVICE_IO_PART_H_
+
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
+
+namespace net {
+class NSSCertDatabase;
+}
+
+namespace cert_database {
+
+// Any object of this class is constructed on the UI thread. Afterward it is
+// initialized on the IO thread, it may only be accessed on IO thread.
+class CertDatabaseServiceIOPart {
+ public:
+  typedef base::Callback<void(net::NSSCertDatabase*)> GetCertDBCallback;
+
+  CertDatabaseServiceIOPart();
+  virtual ~CertDatabaseServiceIOPart();
+
+  virtual void Init();
+
+  // Returns the NSSCertDatabase synchronously if it is already available.
+  // Otherwise passes it asynchronously to |callback| once it is available.
+  WARN_UNUSED_RESULT net::NSSCertDatabase* GetNSSCertDatabase(
+      const GetCertDBCallback& callback);
+
+  base::WeakPtr<CertDatabaseServiceIOPart> GetWeakPtr();

[mmenke, 2014/11/04 20:02:18]

It's generally considered a bad idea to publicly vend weak ptr - that's why
WeakPtrFactory is preferred over SupportsWeakPtr.  Is this all needed to allow
the CertDatabaseServiceIOPart to be destroyed before the ProfileIOData or
something?

[pneubeck (no reviews), 2014/11/05 14:53:38]

Do you know a concrete threat by using WeakPtr in this case?

In the current form, the Service will post in its destructor a task to delete
the IOPart.
Thus, there is no obvious relation to the lifetime of ProfileIOData.

Users of the Service obtain a ptr to the IOPart. They switch (potentially
several loops later) to the IO thread, and can use the IOPart.
If the IOPart is not leaky in the IO thread, the obvious thing seems to be to
use a WeakPtr.

The only sane way (that is without making many global assumptions) that I see to
avoid the WeakPtr is inversion of control. Pass a
Callback<void(CertDatabaseServiceIOPart*)> to Service::GetIOPart.
That however makes it impossible to pass multiple ptrs (say IO parts of
different services) to the IO thread.

I'm sure that I miss some alternatives and would be happy implement it in a
better way.

[mmenke, 2014/11/05 16:19:22]

That's a problem - destruction order is not known or enforced, and the ownership
graph is unclear, as it what does and does not have to worry about the IO part
of the service being destroyed out from under it.  Here's Will Chan's rant on
the topic: 
https://groups.google.com/a/chromium.org/forum/#!msg/chromium-dev/Oy3uuiTSwDk...

I'd rather see the ProfileIOData own the IO part, and it and the UI part talk to
each other via weak ptrs, if that's needed.  Then only one class has to worry
about the relevant cleanup logic, and what's safe to expose.  In general, should
limit the scope of WeakPtrs.

The nice thing about ProfileKeyedService is a profile doesn't have to know about
the service, but the ProfileIOData already has to know about this class anyways,
so I don't think we really get much from not making the ProfileIOData own it. 
I'm open to other ideas.

+
+ protected:
+  // Returns false until Init() is called.
+  bool IsInitialized();
+
+  // Stores |db| and calls all pending GetNSSCertDatabase callbacks.
+  void SetNSSCertDatabase(scoped_ptr<net::NSSCertDatabase> db);
+
+  base::ThreadChecker thread_checker_;
+
+ private:
+  // False until Init() is called.
+  bool initialized_;
+
+  scoped_ptr<net::NSSCertDatabase> nss_cert_database_;
+  std::vector<GetCertDBCallback> get_cert_db_callbacks_;
+  base::WeakPtrFactory<CertDatabaseServiceIOPart> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CertDatabaseServiceIOPart);
+};
+
+}  // namespace cert_database
+
+#endif  // COMPONENTS_CERT_DATABASE_PUBLIC_CERT_DATABASE_SERVICE_IO_PART_H_