Change infobar creation to use a public static Create() method on the infobar delegate classes.

chrome/browser/chrome_quota_permission_context.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 "chrome/browser/chrome_quota_permission_context.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/utf_string_conversions.h"
@@ skipping 20 matching lines @@
 namespace {
 
 // If we requested larger quota than this threshold, show a different
 // message to the user.
 const int64 kRequestLargeQuotaThreshold = 5 * 1024 * 1024;
 
 class RequestQuotaInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   typedef QuotaPermissionContext::PermissionCallback PermissionCallback;
 
+  // Creates a request quota infobar delegate and adds it to |infobar_service|.
+  static void Create(
+      InfoBarService* infobar_service,
+      ChromeQuotaPermissionContext* context,
+      const GURL& origin_url,
+      int64 requested_quota,
+      const std::string& display_languages,
+      const PermissionCallback& callback);
+
+ private:
   RequestQuotaInfoBarDelegate(
       InfoBarService* infobar_service,
       ChromeQuotaPermissionContext* context,
       const GURL& origin_url,
       int64 requested_quota,
       const std::string& display_languages,
       const PermissionCallback& callback)
       : ConfirmInfoBarDelegate(infobar_service),
         context_(context),
         origin_url_(origin_url),
         display_languages_(display_languages),
         requested_quota_(requested_quota),
         callback_(callback) {}
 
- private:
   virtual ~RequestQuotaInfoBarDelegate() {
     if (!callback_.is_null())
       context_->DispatchCallbackOnIOThread(
           callback_,
           QuotaPermissionContext::QUOTA_PERMISSION_RESPONSE_CANCELLED);
   }
 
   virtual bool ShouldExpireInternal(
       const content::LoadCommittedDetails& details)
       const OVERRIDE {
     return false;
   }
 
   virtual string16 GetMessageText() const OVERRIDE;
   virtual bool Accept() OVERRIDE;
   virtual bool Cancel() OVERRIDE;
 
   scoped_refptr<ChromeQuotaPermissionContext> context_;
   GURL origin_url_;
   std::string display_languages_;
   int64 requested_quota_;
   PermissionCallback callback_;
   DISALLOW_COPY_AND_ASSIGN(RequestQuotaInfoBarDelegate);
 };
 
+// static
+void RequestQuotaInfoBarDelegate::Create(
+    InfoBarService* infobar_service,
+    ChromeQuotaPermissionContext* context,
+    const GURL& origin_url,
+    int64 requested_quota,
+    const std::string& display_languages,
+    const QuotaPermissionContext::PermissionCallback& callback) {
+  infobar_service->AddInfoBar(scoped_ptr<InfoBarDelegate>(
+      new RequestQuotaInfoBarDelegate(infobar_service, context, origin_url,
+                                      requested_quota, display_languages,
+                                      callback)));
+}
+
 string16 RequestQuotaInfoBarDelegate::GetMessageText() const {
   return l10n_util::GetStringFUTF16(
       (requested_quota_ > kRequestLargeQuotaThreshold ?
           IDS_REQUEST_LARGE_QUOTA_INFOBAR_QUESTION :
           IDS_REQUEST_QUOTA_INFOBAR_QUESTION),
       net::FormatUrl(origin_url_, display_languages_));
 }
 
 bool RequestQuotaInfoBarDelegate::Accept() {
   context_->DispatchCallbackOnIOThread(
@@ skipping 50 matching lines @@
       InfoBarService::FromWebContents(web_contents);
   if (!infobar_service) {
     // The tab has no infobar service.
     LOG(WARNING) << "Attempt to request quota from a background page: "
                  << render_process_id << "," << render_view_id;
     DispatchCallbackOnIOThread(callback, QUOTA_PERMISSION_RESPONSE_CANCELLED);
     return;
   }
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  infobar_service->AddInfoBar(new RequestQuotaInfoBarDelegate(
+  RequestQuotaInfoBarDelegate::Create(
       infobar_service, this, origin_url, requested_quota,
       profile->GetPrefs()->GetString(prefs::kAcceptLanguages),
-      callback));
+      callback);
 }
 
 void ChromeQuotaPermissionContext::DispatchCallbackOnIOThread(
     const PermissionCallback& callback,
     QuotaPermissionResponse response) {
   DCHECK_EQ(false, callback.is_null());
 
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ChromeQuotaPermissionContext::DispatchCallbackOnIOThread,
                    this, callback, response));
     return;
   }
 
   callback.Run(response);
 }
 
 ChromeQuotaPermissionContext::~ChromeQuotaPermissionContext() {}