content/browser: Move more files into the content namespace.

content/browser/cert_store_impl.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/cert_store_impl.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 
+namespace content {
+
+namespace {
+
 template <typename T>
 struct MatchSecond {
   explicit MatchSecond(const T& t) : value(t) {}
 
   template<typename Pair>
   bool operator()(const Pair& p) const {
     return (value == p.second);
   }
   T value;
 };
 
+}  // namespace
+
 // static
-content::CertStore* content::CertStore::GetInstance() {
+CertStore* CertStore::GetInstance() {
   return CertStoreImpl::GetInstance();
 }
 
 //  static
 CertStoreImpl* CertStoreImpl::GetInstance() {
   return Singleton<CertStoreImpl>::get();
 }
 
 CertStoreImpl::CertStoreImpl() : next_cert_id_(1) {
-  if (content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
+  if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     RegisterForNotification();
   } else {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE,
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&CertStoreImpl::RegisterForNotification,
                    base::Unretained(this)));
   }
 }
 
 CertStoreImpl::~CertStoreImpl() {
 }
 
 void CertStoreImpl::RegisterForNotification() {
   // We watch for RenderProcess termination, as this is how we clear
   // certificates for now.
   // TODO(jcampan): we should be listening to events such as resource cached/
   //                removed from cache, and remove the cert when we know it
   //                is not used anymore.
 
-  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-                 content::NotificationService::AllBrowserContextsAndSources());
-  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
-                 content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                 NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                 NotificationService::AllBrowserContextsAndSources());
 }
 
 int CertStoreImpl::StoreCert(net::X509Certificate* cert, int process_id) {
   DCHECK(cert);
   base::AutoLock auto_lock(cert_lock_);
 
   int cert_id;
 
   // Do we already know this cert?
   ReverseCertMap::iterator cert_iter = cert_to_id_.find(cert);
@@ skipping 87 matching lines @@
       // The current cert id is not referenced by any other processes, so
       // remove it from id_to_cert_ and cert_to_id_.
       RemoveCertInternal(cert_id);
     }
   }
   if (process_ids.first != process_ids.second)
     process_id_to_cert_id_.erase(process_ids.first, process_ids.second);
 }
 
 void CertStoreImpl::Observe(int type,
-                            const content::NotificationSource& source,
-                            const content::NotificationDetails& details) {
-  DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_TERMINATED ||
-         type == content::NOTIFICATION_RENDERER_PROCESS_CLOSED);
-  content::RenderProcessHost* rph =
-      content::Source<content::RenderProcessHost>(source).ptr();
+                            const NotificationSource& source,
+                            const NotificationDetails& details) {
+  DCHECK(type == NOTIFICATION_RENDERER_PROCESS_TERMINATED ||
+         type == NOTIFICATION_RENDERER_PROCESS_CLOSED);
+  RenderProcessHost* rph = Source<RenderProcessHost>(source).ptr();
   DCHECK(rph);
   RemoveCertsForRenderProcesHost(rph->GetID());
 }
+
+}  // namespace content