Add chrome://quota-internals/

webkit/quota/quota_manager.h

 // 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.
 
 #ifndef WEBKIT_QUOTA_QUOTA_MANAGER_H_
 #define WEBKIT_QUOTA_QUOTA_MANAGER_H_
 #pragma once
 
 #include <deque>
 #include <list>
@@ skipping 12 matching lines @@
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/quota_types.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace base {
 class MessageLoopProxy;
 }
 class FilePath;
 
+namespace quota_internals {
+class QuotaInternalsProxy;
+}
+
 namespace quota {
 
 class QuotaDatabase;
 class UsageTracker;
 
 struct QuotaManagerDeleter;
 class QuotaManagerProxy;
 
 // An interface called by QuotaTemporaryStorageEvictor.
 class QuotaEvictionHandler {
@@ skipping 23 matching lines @@
   virtual void GetUsageAndQuotaForEviction(
       GetUsageAndQuotaForEvictionCallback* callback) = 0;
 };
 
 // The quota manager class.  This class is instantiated per profile and
 // held by the profile.  With the exception of the constructor and the
 // proxy() method, all methods should only be called on the IO thread.
 class QuotaManager : public QuotaTaskObserver,
                      public QuotaEvictionHandler,
                      public base::RefCountedThreadSafe<
-                         QuotaManager, QuotaManagerDeleter> {
+                         QuotaManager, QuotaManagerDeleter>,
+                     public base::SupportsWeakPtr<QuotaManager> {

[michaeln, 2011/05/30 19:36:57]

Is this really needed?

From the WebUI ctor, it looks like an instance is scoped to the life of an
individual tab (which will hold the profile open). And the
QuotaInternalsMessageHandler is scoped to the WebUI. And it looks like
QuotaInternalsHTMLSource instance is scoped to the Profile (although when do
they get removed?).

Seems like you could safely addref the quota_manager from within your UI handler
stuff.

I guess what i'm asking is, what are the lifecycles of these objects..
 QuotaInternalsUI
 QuotaInternalsMessageHandler 
 QuotaInternalsHTMLSource 

[tzik, 2011/05/31 04:53:01]

I'm sure that we can use scoped_ptr<QuotaManager> safely in
QuotaInternals{UI,MessageHandler,HTMLSource} as you say.
But I think, QuotaInternalsProxy is also owned by tasks made from
Run***On{IO,UI}Thread. So, QuotaInternalsProxy may have longer lifetime than
QuotaInternalsMessageHandler.
I'm afraid scoped_refptr in QuotaInternalsProxy expands the lifetime of
QuotaManager.
I'm not sure that causes no problem.

  public:
   typedef Callback3<QuotaStatusCode,
                     int64 /* usage */,
                     int64 /* quota */>::Type GetUsageAndQuotaCallback;
   typedef Callback2<QuotaStatusCode,
                     int64 /* granted_quota */>::Type RequestQuotaCallback;
 
   QuotaManager(bool is_incognito,
                const FilePath& profile_path,
                base::MessageLoopProxy* io_thread,
@@ skipping 117 matching lines @@
         get_usage_and_quota_callback;
     int64 usage;
     int64 unlimited_usage;
     int64 quota;
   };
 
   typedef std::pair<std::string, StorageType> HostAndType;
   typedef std::map<HostAndType, UsageAndQuotaDispatcherTask*>
       UsageAndQuotaDispatcherTaskMap;
 
+  friend class quota_internals::QuotaInternalsProxy;
   friend struct QuotaManagerDeleter;
   friend class QuotaManagerProxy;
   friend class QuotaManagerTest;
 
   // This initialization method is lazily called on the IO thread
   // when the first quota manager API is called.
   // Initialize must be called after all quota clients are added to the
   // manager by RegisterStorage.
   void LazyInitialize();
 
@@ skipping 115 matching lines @@
 
   QuotaManager* manager_;  // only accessed on the io thread
   scoped_refptr<base::MessageLoopProxy> io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerProxy);
 };
 
 }  // namespace quota
 
 #endif  // WEBKIT_QUOTA_QUOTA_MANAGER_H_