Convert infobar APIs to UTF-16.

chrome/browser/notifications/desktop_notification_service.cc

 // 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.
 
 #include "chrome/browser/notifications/desktop_notification_service.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/thread.h"
 #include "base/utf_string_conversions.h"
@@ skipping 99 matching lines @@
   int route_id_;
   int request_id_;
 };
 
 // The delegate for the infobar shown when an origin requests notification
 // permissions.
 class NotificationPermissionInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   NotificationPermissionInfoBarDelegate(TabContents* contents,
                                         const GURL& origin,
-                                        const std::wstring& display_name,
+                                        const string16& display_name,
                                         int process_id,
                                         int route_id,
                                         int callback_context)
       : ConfirmInfoBarDelegate(contents),
         origin_(origin),
         display_name_(display_name),
         profile_(contents->profile()),
         process_id_(process_id),
         route_id_(route_id),
         callback_context_(callback_context),
         action_taken_(false) {
   }
 
   // Overridden from ConfirmInfoBarDelegate:
   virtual void InfoBarClosed() {
     if (!action_taken_)
       UMA_HISTOGRAM_COUNTS("NotificationPermissionRequest.Ignored", 1);
 
     ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       new NotificationPermissionCallbackTask(
           process_id_, route_id_, callback_context_));
 
     delete this;
   }
 
-  virtual std::wstring GetMessageText() const {
-    return l10n_util::GetStringF(IDS_NOTIFICATION_PERMISSIONS, display_name_);
+  virtual string16 GetMessageText() const {
+    return l10n_util::GetStringFUTF16(IDS_NOTIFICATION_PERMISSIONS,
+                                      display_name_);
   }
 
   virtual SkBitmap* GetIcon() const {
     return ResourceBundle::GetSharedInstance().GetBitmapNamed(
        IDR_PRODUCT_ICON_32);
   }
 
   virtual int GetButtons() const {
     return BUTTON_OK | BUTTON_CANCEL | BUTTON_OK_DEFAULT;
   }
 
-  virtual std::wstring GetButtonLabel(InfoBarButton button) const {
+  virtual string16 GetButtonLabel(InfoBarButton button) const {
     return button == BUTTON_OK ?
-        l10n_util::GetString(IDS_NOTIFICATION_PERMISSION_YES) :
-        l10n_util::GetString(IDS_NOTIFICATION_PERMISSION_NO);
+        l10n_util::GetStringUTF16(IDS_NOTIFICATION_PERMISSION_YES) :
+        l10n_util::GetStringUTF16(IDS_NOTIFICATION_PERMISSION_NO);
   }
 
   virtual bool Accept() {
     UMA_HISTOGRAM_COUNTS("NotificationPermissionRequest.Allowed", 1);
     profile_->GetDesktopNotificationService()->GrantPermission(origin_);
     action_taken_ = true;
     return true;
   }
 
   virtual bool Cancel() {
     UMA_HISTOGRAM_COUNTS("NotificationPermissionRequest.Denied", 1);
     profile_->GetDesktopNotificationService()->DenyPermission(origin_);
     action_taken_ = true;
     return true;
   }
 
   // Overridden from InfoBarDelegate:
   virtual Type GetInfoBarType() { return PAGE_ACTION_TYPE; }
 
  private:
   // The origin we are asking for permissions on.
   GURL origin_;
 
   // The display name for the origin to be displayed.  Will be different from
   // origin_ for extensions.
-  std::wstring display_name_;
+  string16 display_name_;
 
   // The Profile that we restore sessions from.
   Profile* profile_;
 
   // The callback information that tells us how to respond to javascript via
   // the correct RenderView.
   int process_id_;
   int route_id_;
   int callback_context_;
 
@@ skipping 310 matching lines @@
   if (!tab)
     return;
 
   // If |origin| hasn't been seen before and the default content setting for
   // notifications is "ask", show an infobar.
   // The cache can only answer queries on the IO thread once it's initialized,
   // so don't ask the cache.
   ContentSetting setting = GetContentSetting(origin);
   if (setting == CONTENT_SETTING_ASK) {
     // Show an info bar requesting permission.
-    std::wstring display_name = UTF16ToWide(DisplayNameForOrigin(origin));
-
     tab->AddInfoBar(new NotificationPermissionInfoBarDelegate(
-        tab, origin, display_name, process_id, route_id, callback_context));
+                        tab, origin, DisplayNameForOrigin(origin), process_id,
+                        route_id, callback_context));
   } else {
     // Notify renderer immediately.
     ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       new NotificationPermissionCallbackTask(
           process_id, route_id, callback_context));
   }
 }
 
 void DesktopNotificationService::ShowNotification(
@@ skipping 43 matching lines @@
   if (origin.SchemeIs(chrome::kExtensionScheme)) {
     ExtensionsService* ext_service = profile_->GetExtensionsService();
     if (ext_service) {
       Extension* extension = ext_service->GetExtensionByURL(origin);
       if (extension)
         return UTF8ToUTF16(extension->name());
     }
   }
   return UTF8ToUTF16(origin.host());
 }