GuestView: Show status bubbles in browser

chrome/browser/ui/tab_contents/core_tab_helper.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/ui/tab_contents/core_tab_helper.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "extensions/browser/guest_view/guest_view_manager.h"
 #include "net/base/load_states.h"
 #include "net/http/http_request_headers.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::WebContents;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(CoreTabHelper);
 
 CoreTabHelper::CoreTabHelper(WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       delegate_(NULL),
       content_restrictions_(0) {
 }
 
 CoreTabHelper::~CoreTabHelper() {
 }
 
 base::string16 CoreTabHelper::GetDefaultTitle() {
   return l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
 }
 
 base::string16 CoreTabHelper::GetStatusText() const {
-  if (!web_contents()->IsLoading() ||
-      web_contents()->GetLoadState().state == net::LOAD_STATE_IDLE) {
-    return base::string16();
-  }
-
-  switch (web_contents()->GetLoadState().state) {
-    case net::LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL:
-    case net::LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_WAITING_FOR_SOCKET_SLOT);
-    case net::LOAD_STATE_WAITING_FOR_DELEGATE:
-      if (!web_contents()->GetLoadState().param.empty()) {
-        return l10n_util::GetStringFUTF16(IDS_LOAD_STATE_WAITING_FOR_DELEGATE,
-                                          web_contents()->GetLoadState().param);
-      } else {
-        return l10n_util::GetStringUTF16(
-            IDS_LOAD_STATE_WAITING_FOR_DELEGATE_GENERIC);
-      }
-    case net::LOAD_STATE_WAITING_FOR_CACHE:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_WAITING_FOR_CACHE);
-    case net::LOAD_STATE_WAITING_FOR_APPCACHE:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_WAITING_FOR_APPCACHE);
-    case net::LOAD_STATE_ESTABLISHING_PROXY_TUNNEL:
-      return
-          l10n_util::GetStringUTF16(IDS_LOAD_STATE_ESTABLISHING_PROXY_TUNNEL);
-    case net::LOAD_STATE_DOWNLOADING_PROXY_SCRIPT:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_DOWNLOADING_PROXY_SCRIPT);
-    case net::LOAD_STATE_RESOLVING_PROXY_FOR_URL:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_RESOLVING_PROXY_FOR_URL);
-    case net::LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT:
-      return l10n_util::GetStringUTF16(
-          IDS_LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT);
-    case net::LOAD_STATE_RESOLVING_HOST:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_RESOLVING_HOST);
-    case net::LOAD_STATE_CONNECTING:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_CONNECTING);
-    case net::LOAD_STATE_SSL_HANDSHAKE:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_SSL_HANDSHAKE);
-    case net::LOAD_STATE_SENDING_REQUEST:
-      if (web_contents()->GetUploadSize()) {
-        return l10n_util::GetStringFUTF16Int(
-            IDS_LOAD_STATE_SENDING_REQUEST_WITH_PROGRESS,
-            static_cast<int>((100 * web_contents()->GetUploadPosition()) /
-                web_contents()->GetUploadSize()));
-      } else {
-        return l10n_util::GetStringUTF16(IDS_LOAD_STATE_SENDING_REQUEST);
-      }
-    case net::LOAD_STATE_WAITING_FOR_RESPONSE:
-      return l10n_util::GetStringFUTF16(IDS_LOAD_STATE_WAITING_FOR_RESPONSE,
-                                        web_contents()->GetLoadStateHost());
-    // Ignore net::LOAD_STATE_READING_RESPONSE and net::LOAD_STATE_IDLE
-    case net::LOAD_STATE_IDLE:
-    case net::LOAD_STATE_READING_RESPONSE:
-      break;
-  }
-
-  return base::string16();
+  base::string16 status_text;
+  GetStatusTextForWebContents(&status_text, web_contents());
+  return status_text;
 }
 
 void CoreTabHelper::OnCloseStarted() {
   if (close_start_time_.is_null())
     close_start_time_ = base::TimeTicks::Now();
 }
 
 void CoreTabHelper::OnCloseCanceled() {
   close_start_time_ = base::TimeTicks();
   before_unload_end_time_ = base::TimeTicks();
@@ skipping 13 matching lines @@
   content_restrictions_ = content_restrictions;
 #if !defined(OS_ANDROID)
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
   if (!browser)
     return;
 
   browser->command_controller()->ContentRestrictionsChanged();
 #endif
 }
 
+// static
+bool CoreTabHelper::GetStatusTextForWebContents(
+    base::string16* status_text, content::WebContents* source) {
+  auto guest_manager =
+      extensions::GuestViewManager::FromBrowserContextIfAvailable(
+          source->GetBrowserContext());
+  if (!source->IsLoading() ||
+      source->GetLoadState().state == net::LOAD_STATE_IDLE) {
+    if (!guest_manager)
+      return false;
+    return guest_manager->ForEachGuest(
+        source, base::Bind(&CoreTabHelper::GetStatusTextForWebContents,
+                           status_text));
+  }
+
+  switch (source->GetLoadState().state) {
+    case net::LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL:
+    case net::LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET:
+      *status_text =
+          l10n_util::GetStringUTF16(IDS_LOAD_STATE_WAITING_FOR_SOCKET_SLOT);
+      return true;
+    case net::LOAD_STATE_WAITING_FOR_DELEGATE:
+      if (!source->GetLoadState().param.empty()) {
+        *status_text = l10n_util::GetStringFUTF16(
+            IDS_LOAD_STATE_WAITING_FOR_DELEGATE,
+            source->GetLoadState().param);
+        return true;
+      } else {
+        *status_text = l10n_util::GetStringUTF16(
+            IDS_LOAD_STATE_WAITING_FOR_DELEGATE_GENERIC);
+        return true;
+      }
+    case net::LOAD_STATE_WAITING_FOR_CACHE:
+      *status_text =
+          l10n_util::GetStringUTF16(IDS_LOAD_STATE_WAITING_FOR_CACHE);
+      return true;
+    case net::LOAD_STATE_WAITING_FOR_APPCACHE:
+      *status_text =
+          l10n_util::GetStringUTF16(IDS_LOAD_STATE_WAITING_FOR_APPCACHE);
+      return true;
+    case net::LOAD_STATE_ESTABLISHING_PROXY_TUNNEL:
+      *status_text =
+          l10n_util::GetStringUTF16(IDS_LOAD_STATE_ESTABLISHING_PROXY_TUNNEL);
+      return true;
+    case net::LOAD_STATE_DOWNLOADING_PROXY_SCRIPT:
+      *status_text =
+          l10n_util::GetStringUTF16(IDS_LOAD_STATE_DOWNLOADING_PROXY_SCRIPT);
+      return true;
+    case net::LOAD_STATE_RESOLVING_PROXY_FOR_URL:
+      *status_text =
+          l10n_util::GetStringUTF16(IDS_LOAD_STATE_RESOLVING_PROXY_FOR_URL);
+      return true;
+    case net::LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT:
+      *status_text = l10n_util::GetStringUTF16(
+          IDS_LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT);
+      return true;
+    case net::LOAD_STATE_RESOLVING_HOST:
+      *status_text = l10n_util::GetStringUTF16(IDS_LOAD_STATE_RESOLVING_HOST);
+      return true;
+    case net::LOAD_STATE_CONNECTING:
+      *status_text = l10n_util::GetStringUTF16(IDS_LOAD_STATE_CONNECTING);
+      return true;
+    case net::LOAD_STATE_SSL_HANDSHAKE:
+      *status_text = l10n_util::GetStringUTF16(IDS_LOAD_STATE_SSL_HANDSHAKE);
+      return true;
+    case net::LOAD_STATE_SENDING_REQUEST:
+      if (source->GetUploadSize()) {
+        *status_text = l10n_util::GetStringFUTF16Int(
+            IDS_LOAD_STATE_SENDING_REQUEST_WITH_PROGRESS,
+            static_cast<int>((100 * source->GetUploadPosition()) /
+                source->GetUploadSize()));
+        return true;
+      } else {
+        *status_text =
+            l10n_util::GetStringUTF16(IDS_LOAD_STATE_SENDING_REQUEST);
+        return true;
+      }
+    case net::LOAD_STATE_WAITING_FOR_RESPONSE:
+      *status_text =
+          l10n_util::GetStringFUTF16(IDS_LOAD_STATE_WAITING_FOR_RESPONSE,
+                                     source->GetLoadStateHost());
+      return true;
+    // Ignore net::LOAD_STATE_READING_RESPONSE and net::LOAD_STATE_IDLE
+    case net::LOAD_STATE_IDLE:
+    case net::LOAD_STATE_READING_RESPONSE:
+      break;
+  }
+  if (!guest_manager)
+    return false;
+  return guest_manager->ForEachGuest(
+      source, base::Bind(&CoreTabHelper::GetStatusTextForWebContents,
+                         status_text));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsObserver overrides
 
 void CoreTabHelper::DidStartLoading(content::RenderViewHost* render_view_host) {
   UpdateContentRestrictions(0);
 }
 
 void CoreTabHelper::WasShown() {
   web_cache::WebCacheManager::GetInstance()->ObserveActivity(
       web_contents()->GetRenderProcessHost()->GetID());
@@ skipping 92 matching lines @@
     DCHECK(!content_type.empty());
     open_url_params.uses_post = true;
     open_url_params.browser_initiated_post_data =
         base::RefCountedString::TakeString(post_data);
     open_url_params.extra_headers += base::StringPrintf(
         "%s: %s\r\n", net::HttpRequestHeaders::kContentType,
         content_type.c_str());
   }
   web_contents()->OpenURL(open_url_params);
 }