Replace string16 with base::string16.

chrome/browser/background/background_contents_service.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/background/background_contents_service.h"
 
 #include "apps/app_load_service.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 140 matching lines @@
   bool is_hosted_app_;
   bool is_platform_app_;
   std::string extension_id_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashNotificationDelegate);
 };
 
 #if defined(ENABLE_NOTIFICATIONS)
 void NotificationImageReady(
     const std::string extension_name,
-    const string16 message,
+    const base::string16 message,
     const GURL extension_url,
     scoped_refptr<CrashNotificationDelegate> delegate,
     Profile* profile,
     const gfx::Image& icon) {
   gfx::Image notification_icon(icon);
   if (icon.IsEmpty()) {
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     notification_icon = rb.GetImageNamed(IDR_EXTENSION_DEFAULT_ICON);
   }
-  string16 title;  // no notification title
+  base::string16 title;  // no notification title
   DesktopNotificationService::AddIconNotification(extension_url,
                                                   title,
                                                   message,
                                                   notification_icon,
-                                                  string16(),
+                                                  base::string16(),
                                                   delegate.get(),
                                                   profile);
 }
 #endif
 
 // Show a popup notification balloon with a crash message for a given app/
 // extension.
 void ShowBalloon(const Extension* extension, Profile* profile) {
 #if defined(ENABLE_NOTIFICATIONS)
-  const string16 message = l10n_util::GetStringFUTF16(
+  const base::string16 message = l10n_util::GetStringFUTF16(
       extension->is_app() ? IDS_BACKGROUND_CRASHED_APP_BALLOON_MESSAGE :
                             IDS_BACKGROUND_CRASHED_EXTENSION_BALLOON_MESSAGE,
       UTF8ToUTF16(extension->name()));
   extension_misc::ExtensionIcons size(extension_misc::EXTENSION_ICON_MEDIUM);
   extensions::ExtensionResource resource =
       extensions::IconsInfo::GetIconResource(
           extension, size, ExtensionIconSet::MATCH_SMALLER);
   // We can't just load the image in the Observe method below because, despite
   // what this method is called, it may call the callback synchronously.
   // However, it's possible that the extension went away during the interim,
@@ skipping 158 matching lines @@
       // change notification there.
       break;
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED: {
       DCHECK(IsTracked(content::Details<BackgroundContents>(details).ptr()));
 
       // Do not register in the pref if the extension has a manifest-specified
       // background page.
       BackgroundContents* bgcontents =
           content::Details<BackgroundContents>(details).ptr();
       Profile* profile = content::Source<Profile>(source).ptr();
-      const string16& appid = GetParentApplicationId(bgcontents);
+      const base::string16& appid = GetParentApplicationId(bgcontents);
       ExtensionService* extension_service =
           extensions::ExtensionSystem::Get(profile)->extension_service();
       // extension_service can be NULL when running tests.
       if (extension_service) {
         const Extension* extension =
             extension_service->GetExtensionById(UTF16ToUTF8(appid), false);
         if (extension && BackgroundInfo::HasBackgroundPage(extension))
           break;
       }
       RegisterBackgroundContents(bgcontents);
@@ skipping 190 matching lines @@
     const DictionaryValue* contents) {
   ExtensionService* extensions_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   DCHECK(extensions_service);
 
   const DictionaryValue* dict;
   if (!contents->GetDictionaryWithoutPathExpansion(extension_id, &dict) ||
       dict == NULL)
     return;
 
-  string16 frame_name;
+  base::string16 frame_name;
   std::string url;
   dict->GetString(kUrlKey, &url);
   dict->GetString(kFrameNameKey, &frame_name);
   LoadBackgroundContents(profile,
                          GURL(url),
                          frame_name,
                          UTF8ToUTF16(extension_id));
 }
 
 void BackgroundContentsService::LoadBackgroundContentsFromManifests(
     Profile* profile) {
   const ExtensionSet* extensions = extensions::ExtensionSystem::Get(profile)->
       extension_service()->extensions();
   ExtensionSet::const_iterator iter = extensions->begin();
   for (; iter != extensions->end(); ++iter) {
     const Extension* extension = iter->get();
     if (extension->is_hosted_app() &&
         BackgroundInfo::HasBackgroundPage(extension)) {
       LoadBackgroundContents(profile,
                              BackgroundInfo::GetBackgroundURL(extension),
                              ASCIIToUTF16("background"),
                              UTF8ToUTF16(extension->id()));
     }
   }
 }
 
 void BackgroundContentsService::LoadBackgroundContents(
     Profile* profile,
     const GURL& url,
-    const string16& frame_name,
-    const string16& application_id) {
+    const base::string16& frame_name,
+    const base::string16& application_id) {
   // We are depending on the fact that we will initialize before any user
   // actions or session restore can take place, so no BackgroundContents should
   // be running yet for the passed application_id.
   DCHECK(!GetAppBackgroundContents(application_id));
   DCHECK(!application_id.empty());
   DCHECK(url.is_valid());
   DVLOG(1) << "Loading background content url: " << url;
 
   BackgroundContents* contents = CreateBackgroundContents(
       SiteInstance::CreateForURL(profile, url),
       MSG_ROUTING_NONE,
       profile,
       frame_name,
       application_id,
       std::string(),
       NULL);
 
   // TODO(atwilson): Create RenderViews asynchronously to avoid increasing
   // startup latency (http://crbug.com/47236).
   contents->web_contents()->GetController().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
 }
 
 BackgroundContents* BackgroundContentsService::CreateBackgroundContents(
     SiteInstance* site,
     int routing_id,
     Profile* profile,
-    const string16& frame_name,
-    const string16& application_id,
+    const base::string16& frame_name,
+    const base::string16& application_id,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
   BackgroundContents* contents = new BackgroundContents(
       site, routing_id, this, partition_id, session_storage_namespace);
 
   // Register the BackgroundContents internally, then send out a notification
   // to external listeners.
   BackgroundContentsOpenedDetails details = {contents,
                                              frame_name,
                                              application_id};
@@ skipping 13 matching lines @@
   DCHECK(IsTracked(background_contents));
   if (!prefs_)
     return;
 
   // We store the first URL we receive for a given application. If there's
   // already an entry for this application, no need to do anything.
   // TODO(atwilson): Verify that this is the desired behavior based on developer
   // feedback (http://crbug.com/47118).
   DictionaryPrefUpdate update(prefs_, prefs::kRegisteredBackgroundContents);
   DictionaryValue* pref = update.Get();
-  const string16& appid = GetParentApplicationId(background_contents);
+  const base::string16& appid = GetParentApplicationId(background_contents);
   DictionaryValue* current;
   if (pref->GetDictionaryWithoutPathExpansion(UTF16ToUTF8(appid), &current))
     return;
 
   // No entry for this application yet, so add one.
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(kUrlKey, background_contents->GetURL().spec());
   dict->SetString(kFrameNameKey, contents_map_[appid].frame_name);
   pref->SetWithoutPathExpansion(UTF16ToUTF8(appid), dict);
 }
 
 bool BackgroundContentsService::HasRegisteredBackgroundContents(
-    const string16& app_id) {
+    const base::string16& app_id) {
   if (!prefs_)
     return false;
   std::string app = UTF16ToUTF8(app_id);
   const DictionaryValue* contents =
       prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
   return contents->HasKey(app);
 }
 
 void BackgroundContentsService::UnregisterBackgroundContents(
     BackgroundContents* background_contents) {
   if (!prefs_)
     return;
   DCHECK(IsTracked(background_contents));
-  const string16 appid = GetParentApplicationId(background_contents);
+  const base::string16 appid = GetParentApplicationId(background_contents);
   DictionaryPrefUpdate update(prefs_, prefs::kRegisteredBackgroundContents);
   update.Get()->RemoveWithoutPathExpansion(UTF16ToUTF8(appid), NULL);
 }
 
 void BackgroundContentsService::ShutdownAssociatedBackgroundContents(
-    const string16& appid) {
+    const base::string16& appid) {
   BackgroundContents* contents = GetAppBackgroundContents(appid);
   if (contents) {
     UnregisterBackgroundContents(contents);
     // Background contents destructor shuts down the renderer.
     delete contents;
   }
 }
 
 void BackgroundContentsService::BackgroundContentsOpened(
     BackgroundContentsOpenedDetails* details) {
@@ skipping 10 matching lines @@
 // BackgroundContents is being tracked by this instance.
 bool BackgroundContentsService::IsTracked(
     BackgroundContents* background_contents) const {
   return !GetParentApplicationId(background_contents).empty();
 }
 
 void BackgroundContentsService::BackgroundContentsShutdown(
     BackgroundContents* background_contents) {
   // Remove the passed object from our list.
   DCHECK(IsTracked(background_contents));
-  string16 appid = GetParentApplicationId(background_contents);
+  base::string16 appid = GetParentApplicationId(background_contents);
   contents_map_.erase(appid);
 }
 
 BackgroundContents* BackgroundContentsService::GetAppBackgroundContents(
-    const string16& application_id) {
+    const base::string16& application_id) {
   BackgroundContentsMap::const_iterator it = contents_map_.find(application_id);
   return (it != contents_map_.end()) ? it->second.contents : NULL;
 }
 
-const string16& BackgroundContentsService::GetParentApplicationId(
+const base::string16& BackgroundContentsService::GetParentApplicationId(
     BackgroundContents* contents) const {
   for (BackgroundContentsMap::const_iterator it = contents_map_.begin();
        it != contents_map_.end(); ++it) {
     if (contents == it->second.contents)
       return it->first;
   }
   return base::EmptyString16();
 }
 
 void BackgroundContentsService::AddWebContents(
     WebContents* new_contents,
     WindowOpenDisposition disposition,
     const gfx::Rect& initial_pos,
     bool user_gesture,
     bool* was_blocked) {
   Browser* browser = chrome::FindLastActiveWithProfile(
       Profile::FromBrowserContext(new_contents->GetBrowserContext()),
       chrome::GetActiveDesktop());
   if (browser) {
     chrome::AddWebContents(browser, NULL, new_contents, disposition,
                            initial_pos, user_gesture, was_blocked);
   }
 }