Re-land alexbost's experimental offscreenTabs API.

chrome/browser/extensions/extension_tabs_module.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/extensions/extension_tabs_module.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/browser/extensions/extension_window_controller.h"
 #include "chrome/browser/extensions/extension_window_list.h"
-#include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
@@ skipping 144 matching lines @@
                                    browser, tab_strip, contents, tab_index))
     return true;
 
   if (error_message)
     *error_message = ExtensionErrorUtils::FormatErrorMessage(
         keys::kTabNotFoundError, base::IntToString(tab_id));
 
   return false;
 }
 
-// Takes |url_string| and returns a GURL which is either valid and absolute
-// or invalid. If |url_string| is not directly interpretable as a valid (it is
-// likely a relative URL) an attempt is made to resolve it. |extension| is
-// provided so it can be resolved relative to its extension base
-// (chrome-extension://<id>/). Using the source frame url would be more correct,
-// but because the api shipped with urls resolved relative to their extension
-// base, we decided it wasn't worth breaking existing extensions to fix.
-GURL ResolvePossiblyRelativeURL(const std::string& url_string,
-                                const Extension* extension) {
-  GURL url = GURL(url_string);
-  if (!url.is_valid())
-    url = extension->GetResourceURL(url_string);
-
-  return url;
-}
-
-bool IsCrashURL(const GURL& url) {
-  // Check a fixed-up URL, to normalize the scheme and parse hosts correctly.
-  GURL fixed_url =
-      URLFixerUpper::FixupURL(url.possibly_invalid_spec(), std::string());
-  return (fixed_url.SchemeIs(chrome::kChromeUIScheme) &&
-          (fixed_url.host() == chrome::kChromeUIBrowserCrashHost ||
-           fixed_url.host() == chrome::kChromeUICrashHost));
-}
-
 // Reads the |value| as either a single integer value or a list of integers.
 bool ReadOneOrMoreIntegers(
     Value* value, std::vector<int>* result) {
   if (value->IsType(Value::TYPE_INTEGER)) {
     int tab_id = -1;
     if (!value->GetAsInteger(&tab_id))
       return false;
     result->push_back(tab_id);
     return true;
 
@@ skipping 206 matching lines @@
         for (size_t i = 0; i < url_list->GetSize(); ++i) {
           std::string url_string;
           EXTENSION_FUNCTION_VALIDATE(url_list->GetString(i, &url_string));
           url_strings.push_back(url_string);
         }
       }
 
       // Second, resolve, validate and convert them to GURLs.
       for (std::vector<std::string>::iterator i = url_strings.begin();
            i != url_strings.end(); ++i) {
-        GURL url = ResolvePossiblyRelativeURL(*i, GetExtension());
+        GURL url = ExtensionTabUtil::ResolvePossiblyRelativeURL(
+            *i, GetExtension());
         if (!url.is_valid()) {
           error_ = ExtensionErrorUtils::FormatErrorMessage(
               keys::kInvalidUrlError, *i);
           return false;
         }
         // Don't let the extension crash the browser or renderers.
-        if (IsCrashURL(url)) {
+        if (ExtensionTabUtil::IsCrashURL(url)) {
           error_ = keys::kNoCrashBrowserError;
           return false;
         }
         urls.push_back(url);
       }
     }
   }
 
   // Look for optional tab id.
   if (args) {
@@ skipping 540 matching lines @@
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
 
   std::string url_string;
   GURL url;
   if (args->HasKey(keys::kUrlKey)) {
     EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kUrlKey,
                                                 &url_string));
-    url = ResolvePossiblyRelativeURL(url_string, GetExtension());
+    url = ExtensionTabUtil::ResolvePossiblyRelativeURL(url_string,
+                                                       GetExtension());
     if (!url.is_valid()) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kInvalidUrlError,
                                                        url_string);
       return false;
     }
   }
 
   // Don't let extensions crash the browser or renderers.
-  if (IsCrashURL(url)) {
+  if (ExtensionTabUtil::IsCrashURL(url)) {
     error_ = keys::kNoCrashBrowserError;
     return false;
   }
 
   // Default to foreground for the new tab. The presence of 'selected' property
   // will override this default. This property is deprecated ('active' should
   // be used instead).
   bool active = true;
   if (args->HasKey(keys::kSelectedKey))
     EXTENSION_FUNCTION_VALIDATE(
@@ skipping 176 matching lines @@
   }
 
   int tab_index = -1;
   TabStripModel* tab_strip = NULL;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_)) {
     return false;
   }
 
   web_contents_ = contents->web_contents();
-  NavigationController& controller = web_contents_->GetController();
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
 
-  // We wait to fire the callback when executing 'javascript:' URLs in tabs.
+  // Navigate the tab to a new location if the url is different.
   bool is_async = false;
-
-  // Navigate the tab to a new location if the url is different.
-  std::string url_string;
-  if (update_props->HasKey(keys::kUrlKey)) {
-    EXTENSION_FUNCTION_VALIDATE(update_props->GetString(
-        keys::kUrlKey, &url_string));
-    GURL url = ResolvePossiblyRelativeURL(url_string, GetExtension());
-
-    if (!url.is_valid()) {
-      error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kInvalidUrlError,
-                                                       url_string);
-      return false;
-    }
-
-    // Don't let the extension crash the browser or renderers.
-    if (IsCrashURL(url)) {
-      error_ = keys::kNoCrashBrowserError;
-      return false;
-    }
-
-    // JavaScript URLs can do the same kinds of things as cross-origin XHR, so
-    // we need to check host permissions before allowing them.
-    if (url.SchemeIs(chrome::kJavaScriptScheme)) {
-      if (!GetExtension()->CanExecuteScriptOnPage(
-              web_contents_->GetURL(), NULL, &error_)) {
-        return false;
-      }
-
-      ExtensionMsg_ExecuteCode_Params params;
-      params.request_id = request_id();
-      params.extension_id = extension_id();
-      params.is_javascript = true;
-      params.code = url.path();
-      params.all_frames = false;
-      params.in_main_world = true;
-
-      RenderViewHost* render_view_host = web_contents_->GetRenderViewHost();
-      render_view_host->Send(
-          new ExtensionMsg_ExecuteCode(render_view_host->GetRoutingID(),
-                                       params));
-
-      Observe(web_contents_);
-      AddRef();  // Balanced in OnExecuteCodeFinished().
-
-      is_async = true;
-    }
-
-    controller.LoadURL(
-        url, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
-
-    // The URL of a tab contents never actually changes to a JavaScript URL, so
-    // this check only makes sense in other cases.
-    if (!url.SchemeIs(chrome::kJavaScriptScheme))
-      DCHECK_EQ(url.spec(), web_contents_->GetURL().spec());
-  }
+  if (!UpdateURLIfPresent(update_props, &is_async))
+    return false;
 
   bool active = false;
   // TODO(rafaelw): Setting |active| from js doesn't make much sense.
   // Move tab selection management up to window.
   if (update_props->HasKey(keys::kSelectedKey))
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kSelectedKey, &active));
 
   // The 'active' property has replaced 'selected'.
   if (update_props->HasKey(keys::kActiveKey))
@@ skipping 41 matching lines @@
         tab_index, &opener_contents->web_contents()->GetController());
   }
 
   if (!is_async) {
     PopulateResult();
     SendResponse(true);
   }
   return true;
 }
 
+bool UpdateTabFunction::UpdateURLIfPresent(DictionaryValue* update_props,
+                                           bool* is_async) {
+  if (!update_props->HasKey(keys::kUrlKey))
+    return true;
+
+  std::string url_string;
+  EXTENSION_FUNCTION_VALIDATE(update_props->GetString(
+      keys::kUrlKey, &url_string));
+  GURL url = ExtensionTabUtil::ResolvePossiblyRelativeURL(
+      url_string, GetExtension());
+
+  if (!url.is_valid()) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(
+        keys::kInvalidUrlError, url_string);
+    return false;
+  }
+
+  // Don't let the extension crash the browser or renderers.
+  if (ExtensionTabUtil::IsCrashURL(url)) {
+    error_ = keys::kNoCrashBrowserError;
+    return false;
+  }
+
+  // JavaScript URLs can do the same kinds of things as cross-origin XHR, so
+  // we need to check host permissions before allowing them.
+  if (url.SchemeIs(chrome::kJavaScriptScheme)) {
+    if (!GetExtension()->CanExecuteScriptOnPage(
+            web_contents_->GetURL(), NULL, &error_)) {
+      return false;
+    }
+
+    ExtensionMsg_ExecuteCode_Params params;
+    params.request_id = request_id();
+    params.extension_id = extension_id();
+    params.is_javascript = true;
+    params.code = url.path();
+    params.all_frames = false;
+    params.in_main_world = true;
+
+    RenderViewHost* render_view_host = web_contents_->GetRenderViewHost();
+    render_view_host->Send(
+        new ExtensionMsg_ExecuteCode(render_view_host->GetRoutingID(), params));
+
+    Observe(web_contents_);
+    AddRef();  // Balanced in OnExecuteCodeFinished().
+
+    *is_async = true;
+    return true;
+  }
+
+  web_contents_->GetController().LoadURL(
+      url, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
+
+  // The URL of a tab contents never actually changes to a JavaScript URL, so
+  // this check only makes sense in other cases.
+  if (!url.SchemeIs(chrome::kJavaScriptScheme))
+    DCHECK_EQ(url.spec(), web_contents_->GetURL().spec());
+
+  return true;
+}
+
 void UpdateTabFunction::PopulateResult() {
   if (!has_callback())
     return;
 
   if (GetExtension()->HasAPIPermission(ExtensionAPIPermission::kTab) &&
       web_contents_ != NULL) {
     result_.reset(ExtensionTabUtil::CreateTabValue(web_contents_));
   } else {
     result_.reset(Value::CreateNullValue());
   }
@@ skipping 31 matching lines @@
   if (!error.empty()) {
     CHECK(!success);
     error_ = error;
   }
 
   if (success)
     PopulateResult();
   SendResponse(success);
 
   Observe(NULL);
-  Release();  // Balanced in RunImpl().
+  Release();  // Balanced in UpdateURLIfPresent().
 }
 
 bool MoveTabsFunction::RunImpl() {
   Value* tab_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
 
   std::vector<int> tab_ids;
   EXTENSION_FUNCTION_VALIDATE(ReadOneOrMoreIntegers(tab_value, &tab_ids));
 
   DictionaryValue* update_props = NULL;
@@ skipping 182 matching lines @@
     // is being dragged, or we're in some other nested event loop. This code
     // path should ensure that the tab is safely closed under such
     // circumstances, whereas |Browser::CloseTabContents()| does not.
     RenderViewHost* render_view_host =
         contents->web_contents()->GetRenderViewHost();
     render_view_host->GetDelegate()->Close(render_view_host);
   }
   return true;
 }
 
-bool CaptureVisibleTabFunction::RunImpl() {
+bool CaptureVisibleTabFunction::GetTabToCapture(
+    WebContents** web_contents, TabContentsWrapper** wrapper) {
   Browser* browser = NULL;
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
+  *web_contents = browser->GetSelectedWebContents();
+  if (*web_contents == NULL) {
+    error_ = keys::kInternalVisibleTabCaptureError;
+    return false;
+  }
+
+  *wrapper = browser->GetSelectedTabContentsWrapper();
+
+  return true;
+};
+
+bool CaptureVisibleTabFunction::RunImpl() {
+  WebContents* web_contents = NULL;
+  TabContentsWrapper* wrapper = NULL;
+  if (!GetTabToCapture(&web_contents, &wrapper))
+    return false;
+
   image_format_ = FORMAT_JPEG;  // Default format is JPEG.
   image_quality_ = kDefaultQuality;  // Default quality setting.
 
   if (HasOptionalArgument(1)) {
     DictionaryValue* options = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &options));
 
     if (options->HasKey(keys::kFormatKey)) {
       std::string format;
       EXTENSION_FUNCTION_VALIDATE(
           options->GetString(keys::kFormatKey, &format));
 
       if (format == keys::kFormatValueJpeg) {
         image_format_ = FORMAT_JPEG;
       } else if (format == keys::kFormatValuePng) {
         image_format_ = FORMAT_PNG;
       } else {
         // Schema validation should make this unreachable.
         EXTENSION_FUNCTION_VALIDATE(0);
       }
     }
 
     if (options->HasKey(keys::kQualityKey)) {
       EXTENSION_FUNCTION_VALIDATE(
           options->GetInteger(keys::kQualityKey, &image_quality_));
     }
   }
 
-  WebContents* web_contents = browser->GetSelectedWebContents();
-  if (!web_contents) {
-    error_ = keys::kInternalVisibleTabCaptureError;
-    return false;
-  }
-
   // captureVisibleTab() can return an image containing sensitive information
   // that the browser would otherwise protect.  Ensure the extension has
   // permission to do this.
   if (!GetExtension()->CanCaptureVisiblePage(web_contents->GetURL(), &error_))
     return false;
 
   RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
 
   // If a backing store is cached for the tab we want to capture,
   // and it can be copied into a bitmap, then use it to generate the image.
-  // This may fail if we can not copy a backing store into a bitmap.
   // For example, some uncommon X11 visual modes are not supported by
   // CopyFromBackingStore().
   skia::PlatformCanvas temp_canvas;
   if (render_view_host->CopyFromBackingStore(
           gfx::Rect(), gfx::Size(), &temp_canvas)) {
     VLOG(1) << "captureVisibleTab() got image from backing store.";
     SendResultFromBitmap(skia::GetTopDevice(temp_canvas)->accessBitmap(false));
     return true;
   }
 
   // Ask the renderer for a snapshot of the tab.
-  TabContentsWrapper* wrapper = browser->GetSelectedTabContentsWrapper();
+  wrapper->snapshot_tab_helper()->CaptureSnapshot();
   registrar_.Add(this,
                  chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN,
                  content::Source<WebContents>(wrapper->web_contents()));
   AddRef();  // Balanced in CaptureVisibleTabFunction::Observe().
   wrapper->snapshot_tab_helper()->CaptureSnapshot();
 
   return true;
 }
 
 // If a backing store was not available in CaptureVisibleTabFunction::RunImpl,
@@ skipping 138 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }