Create task_manager namespace and wrap classes related to TaskManager with it.

chrome/browser/task_manager/tab_contents_resource_provider.cc

Index: chrome/browser/task_manager/tab_contents_resource_provider.cc
diff --git a/chrome/browser/task_manager/task_manager_tab_contents_resource_provider.cc b/chrome/browser/task_manager/tab_contents_resource_provider.cc
similarity index 67%
rename from chrome/browser/task_manager/task_manager_tab_contents_resource_provider.cc
rename to chrome/browser/task_manager/tab_contents_resource_provider.cc
index 4f9df073ac3b1df6dd76abf99d91cae429650a5b..ac16898c584747eb1402f2362200783e78741612 100644
--- a/chrome/browser/task_manager/task_manager_tab_contents_resource_provider.cc
+++ b/chrome/browser/task_manager/tab_contents_resource_provider.cc
@@ -2,12 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/task_manager/task_manager_tab_contents_resource_provider.h"
+#include "chrome/browser/task_manager/tab_contents_resource_provider.h"
 
-#include <string>
-
-#include "base/i18n/rtl.h"
-#include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
@@ -15,21 +11,20 @@
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/printing/background_printing_manager.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/tab_contents/tab_util.h"
+#include "chrome/browser/task_manager/renderer_resource.h"
+#include "chrome/browser/task_manager/resource_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/extensions/extension.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/constants.h"
-#include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
@@ -40,69 +35,6 @@ using extensions::Extension;
 
 namespace {
 
-// Returns the appropriate message prefix ID for tabs and extensions,
-// reflecting whether they are apps or in incognito mode.
-int GetMessagePrefixID(bool is_app,
-                       bool is_extension,
-                       bool is_incognito,
-                       bool is_prerender,
-                       bool is_instant_overlay,
-                       bool is_background) {
-  if (is_app) {
-    if (is_background) {
-      return IDS_TASK_MANAGER_BACKGROUND_PREFIX;
-    } else if (is_incognito) {
-      return IDS_TASK_MANAGER_APP_INCOGNITO_PREFIX;
-    } else {
-      return IDS_TASK_MANAGER_APP_PREFIX;
-    }
-  } else if (is_extension) {
-    if (is_incognito)
-      return IDS_TASK_MANAGER_EXTENSION_INCOGNITO_PREFIX;
-    else
-      return IDS_TASK_MANAGER_EXTENSION_PREFIX;
-  } else if (is_prerender) {
-    return IDS_TASK_MANAGER_PRERENDER_PREFIX;
-  } else if (is_instant_overlay) {
-    return IDS_TASK_MANAGER_INSTANT_OVERLAY_PREFIX;
-  } else {
-    return IDS_TASK_MANAGER_TAB_PREFIX;
-  }
-}
-
-string16 GetProfileNameFromInfoCache(Profile* profile) {
-  ProfileInfoCache& cache =
-      g_browser_process->profile_manager()->GetProfileInfoCache();
-  size_t index = cache.GetIndexOfProfileWithPath(
-      profile->GetOriginalProfile()->GetPath());
-  if (index == std::string::npos)
-    return string16();
-  else
-    return cache.GetNameOfProfileAtIndex(index);
-}
-
-string16 GetTitleFromWebContents(WebContents* web_contents) {
-  string16 title = web_contents->GetTitle();
-  if (title.empty()) {
-    GURL url = web_contents->GetURL();
-    title = UTF8ToUTF16(url.spec());
-    // Force URL to be LTR.
-    title = base::i18n::GetDisplayStringInLTRDirectionality(title);
-  } else {
-    // Since the tab_title will be concatenated with
-    // IDS_TASK_MANAGER_TAB_PREFIX, we need to explicitly set the tab_title to
-    // be LTR format if there is no strong RTL charater in it. Otherwise, if
-    // IDS_TASK_MANAGER_TAB_PREFIX is an RTL word, the concatenated result
-    // might be wrong. For example, http://mail.yahoo.com, whose title is
-    // "Yahoo! Mail: The best web-based Email!", without setting it explicitly
-    // as LTR format, the concatenated result will be "!Yahoo! Mail: The best
-    // web-based Email :BAT", in which the capital letters "BAT" stands for
-    // the Hebrew word for "tab".
-    base::i18n::AdjustStringForLocaleDirection(&title);
-  }
-  return title;
-}
-
 bool IsContentsPrerendering(WebContents* web_contents) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
@@ -132,18 +64,45 @@ bool IsContentsBackgroundPrinted(WebContents* web_contents) {
 
 }  // namespace
 
-////////////////////////////////////////////////////////////////////////////////
-// TaskManagerTabContentsResource class
-////////////////////////////////////////////////////////////////////////////////
+namespace task_manager {
+
+// Tracks a single tab contents, prerendered page, Instant page, or background
+// printing page.
+class TabContentsResource : public RendererResource {
+ public:
+  explicit TabContentsResource(content::WebContents* web_contents);
+  virtual ~TabContentsResource();
+
+  // Called when the underlying web_contents has been committed and is no
+  // longer an Instant overlay.
+  void InstantCommitted();
+
+  // TaskManager::Resource methods:
+  virtual Type GetType() const OVERRIDE;
+  virtual string16 GetTitle() const OVERRIDE;
+  virtual string16 GetProfileName() const OVERRIDE;
+  virtual gfx::ImageSkia GetIcon() const OVERRIDE;
+  virtual content::WebContents* GetWebContents() const OVERRIDE;
+  virtual const extensions::Extension* GetExtension() const OVERRIDE;
 
-// static
-gfx::ImageSkia* TaskManagerTabContentsResource::prerender_icon_ = NULL;
+ private:
+  // Returns true if contains content rendered by an extension.
+  bool HostsExtension() const;
 
-TaskManagerTabContentsResource::TaskManagerTabContentsResource(
+  static gfx::ImageSkia* prerender_icon_;
+  content::WebContents* web_contents_;
+  Profile* profile_;
+  bool is_instant_overlay_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabContentsResource);
+};
+
+gfx::ImageSkia* TabContentsResource::prerender_icon_ = NULL;
+
+TabContentsResource::TabContentsResource(
     WebContents* web_contents)
-    : TaskManagerRendererResource(
-          web_contents->GetRenderProcessHost()->GetHandle(),
-          web_contents->GetRenderViewHost()),
+    : RendererResource(web_contents->GetRenderProcessHost()->GetHandle(),
+                       web_contents->GetRenderViewHost()),
       web_contents_(web_contents),
       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       is_instant_overlay_(IsContentsInstant(web_contents)) {
@@ -153,26 +112,26 @@ TaskManagerTabContentsResource::TaskManagerTabContentsResource(
   }
 }
 
-TaskManagerTabContentsResource::~TaskManagerTabContentsResource() {
+TabContentsResource::~TabContentsResource() {
 }
 
-void TaskManagerTabContentsResource::InstantCommitted() {
+void TabContentsResource::InstantCommitted() {
   DCHECK(is_instant_overlay_);
   is_instant_overlay_ = false;
 }
 
-bool TaskManagerTabContentsResource::HostsExtension() const {
+bool TabContentsResource::HostsExtension() const {
   return web_contents_->GetURL().SchemeIs(extensions::kExtensionScheme);
 }
 
-TaskManager::Resource::Type TaskManagerTabContentsResource::GetType() const {
+TaskManager::Resource::Type TabContentsResource::GetType() const {
   return HostsExtension() ? EXTENSION : RENDERER;
 }
 
-string16 TaskManagerTabContentsResource::GetTitle() const {
+string16 TabContentsResource::GetTitle() const {
   // Fall back on the URL if there's no title.
   GURL url = web_contents_->GetURL();
-  string16 tab_title = GetTitleFromWebContents(web_contents_);
+  string16 tab_title = ResourceUtil::GetTitleFromWebContents(web_contents_);
 
   // Only classify as an app if the URL is an app and the tab is hosting an
   // extension process.  (It's possible to be showing the URL from before it
@@ -182,32 +141,32 @@ string16 TaskManagerTabContentsResource::GetTitle() const {
   bool is_app = extension_service->IsInstalledApp(url) &&
       process_map->Contains(web_contents_->GetRenderProcessHost()->GetID());
 
-  int message_id = GetMessagePrefixID(
+  int message_id = ResourceUtil::GetMessagePrefixID(
       is_app,
       HostsExtension(),
       profile_->IsOffTheRecord(),
       IsContentsPrerendering(web_contents_),
       is_instant_overlay_,
-      false);
+      false);  // is_background
   return l10n_util::GetStringFUTF16(message_id, tab_title);
 }
 
-string16 TaskManagerTabContentsResource::GetProfileName() const {
-  return GetProfileNameFromInfoCache(profile_);
+string16 TabContentsResource::GetProfileName() const {
+  return ResourceUtil::GetProfileNameFromInfoCache(profile_);
 }
 
-gfx::ImageSkia TaskManagerTabContentsResource::GetIcon() const {
+gfx::ImageSkia TabContentsResource::GetIcon() const {
   if (IsContentsPrerendering(web_contents_))
     return *prerender_icon_;
   return FaviconTabHelper::FromWebContents(web_contents_)->
       GetFavicon().AsImageSkia();
 }
 
-WebContents* TaskManagerTabContentsResource::GetWebContents() const {
+WebContents* TabContentsResource::GetWebContents() const {
   return web_contents_;
 }
 
-const Extension* TaskManagerTabContentsResource::GetExtension() const {
+const Extension* TabContentsResource::GetExtension() const {
   if (HostsExtension()) {
     ExtensionService* extension_service = profile_->GetExtensionService();
     return extension_service->extensions()->GetByID(
@@ -218,20 +177,19 @@ const Extension* TaskManagerTabContentsResource::GetExtension() const {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// TaskManagerTabContentsResourceProvider class
+// TabContentsResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
 
-TaskManagerTabContentsResourceProvider::
-    TaskManagerTabContentsResourceProvider(TaskManager* task_manager)
+TabContentsResourceProvider::
+    TabContentsResourceProvider(TaskManager* task_manager)
     :  updating_(false),
        task_manager_(task_manager) {
 }
 
-TaskManagerTabContentsResourceProvider::
-    ~TaskManagerTabContentsResourceProvider() {
+TabContentsResourceProvider::~TabContentsResourceProvider() {
 }
 
-TaskManager::Resource* TaskManagerTabContentsResourceProvider::GetResource(
+TaskManager::Resource* TabContentsResourceProvider::GetResource(
     int origin_pid,
     int render_process_host_id,
     int routing_id) {
@@ -245,7 +203,7 @@ TaskManager::Resource* TaskManagerTabContentsResourceProvider::GetResource(
   if (origin_pid)
     return NULL;
 
-  std::map<WebContents*, TaskManagerTabContentsResource*>::iterator
+  std::map<WebContents*, TabContentsResource*>::iterator
       res_iter = resources_.find(web_contents);
   if (res_iter == resources_.end()) {
     // Can happen if the tab was closed while a network request was being
@@ -255,7 +213,7 @@ TaskManager::Resource* TaskManagerTabContentsResourceProvider::GetResource(
   return res_iter->second;
 }
 
-void TaskManagerTabContentsResourceProvider::StartUpdating() {
+void TabContentsResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
@@ -309,7 +267,7 @@ void TaskManagerTabContentsResourceProvider::StartUpdating() {
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
-void TaskManagerTabContentsResourceProvider::StopUpdating() {
+void TabContentsResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
@@ -329,15 +287,13 @@ void TaskManagerTabContentsResourceProvider::StopUpdating() {
   resources_.clear();
 }
 
-void TaskManagerTabContentsResourceProvider::AddToTaskManager(
-    WebContents* web_contents) {
-  TaskManagerTabContentsResource* resource =
-      new TaskManagerTabContentsResource(web_contents);
+void TabContentsResourceProvider::AddToTaskManager(WebContents* web_contents) {
+  TabContentsResource* resource = new TabContentsResource(web_contents);
   resources_[web_contents] = resource;
   task_manager_->AddResource(resource);
 }
 
-void TaskManagerTabContentsResourceProvider::Add(WebContents* web_contents) {
+void TabContentsResourceProvider::Add(WebContents* web_contents) {
   if (!updating_)
     return;
 
@@ -367,10 +323,10 @@ void TaskManagerTabContentsResourceProvider::Add(WebContents* web_contents) {
   AddToTaskManager(web_contents);
 }
 
-void TaskManagerTabContentsResourceProvider::Remove(WebContents* web_contents) {
+void TabContentsResourceProvider::Remove(WebContents* web_contents) {
   if (!updating_)
     return;
-  std::map<WebContents*, TaskManagerTabContentsResource*>::iterator
+  std::map<WebContents*, TabContentsResource*>::iterator
       iter = resources_.find(web_contents);
   if (iter == resources_.end()) {
     // Since WebContents are destroyed asynchronously (see TabContentsCollector
@@ -381,7 +337,7 @@ void TaskManagerTabContentsResourceProvider::Remove(WebContents* web_contents) {
   }
 
   // Remove the resource from the Task Manager.
-  TaskManagerTabContentsResource* resource = iter->second;
+  TabContentsResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
   // And from the provider.
   resources_.erase(iter);
@@ -389,18 +345,17 @@ void TaskManagerTabContentsResourceProvider::Remove(WebContents* web_contents) {
   delete resource;
 }
 
-void TaskManagerTabContentsResourceProvider::InstantCommitted(
-    WebContents* web_contents) {
+void TabContentsResourceProvider::InstantCommitted(WebContents* web_contents) {
   if (!updating_)
     return;
-  std::map<WebContents*, TaskManagerTabContentsResource*>::iterator
+  std::map<WebContents*, TabContentsResource*>::iterator
       iter = resources_.find(web_contents);
   DCHECK(iter != resources_.end());
   if (iter != resources_.end())
     iter->second->InstantCommitted();
 }
 
-void TaskManagerTabContentsResourceProvider::Observe(
+void TabContentsResourceProvider::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ -425,3 +380,5 @@ void TaskManagerTabContentsResourceProvider::Observe(
       return;
   }
 }
+
+}  // namespace task_manager