Implement <webview>.addContentScript/removeContentScript API [1]

extensions/browser/api/web_view/web_view_internal_api.cc

 // Copyright 2014 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 "extensions/browser/api/web_view/web_view_internal_api.h"
 
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/stop_find_action.h"
 #include "extensions/common/api/web_view_internal.h"
+#include "extensions/common/error_utils.h"
+#include "extensions/common/user_script.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 
 using content::WebContents;
 using extensions::core_api::web_view_internal::SetPermission::Params;
 using extensions::core_api::extension_types::InjectDetails;
+using extensions::core_api::web_view_internal::ContentScriptDetails;
+using extensions::ExtensionResource;
+using extensions::UserScript;
 namespace webview = extensions::core_api::web_view_internal;
 
 namespace {
 
 const char kAppCacheKey[] = "appcache";
 const char kCookiesKey[] = "cookies";
 const char kFileSystemsKey[] = "fileSystems";
 const char kIndexedDBKey[] = "indexedDB";
 const char kLocalStorageKey[] = "localStorage";
 const char kWebSQLKey[] = "webSQL";
 const char kSinceKey[] = "since";
 
 int MaskForKey(const char* key) {
   if (strcmp(key, kAppCacheKey) == 0)
     return content::StoragePartition::REMOVE_DATA_MASK_APPCACHE;
   if (strcmp(key, kCookiesKey) == 0)
     return content::StoragePartition::REMOVE_DATA_MASK_COOKIES;
   if (strcmp(key, kFileSystemsKey) == 0)
     return content::StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
   if (strcmp(key, kIndexedDBKey) == 0)
     return content::StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
   if (strcmp(key, kLocalStorageKey) == 0)
     return content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
   if (strcmp(key, kWebSQLKey) == 0)
     return content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
   return 0;
 }
 
+scoped_ptr<const HostID> GenerateHostID(const extensions::Extension* extension,
+                                        const content::RenderViewHost* rvh) {
+  if (extension)
+    return scoped_ptr<const HostID>(
+        new HostID(HostID::EXTENSIONS, extension->id()));
+  if (rvh) {
+    WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
+    if (web_contents && web_contents->GetWebUI()) {
+      const GURL& url = rvh->GetSiteInstance()->GetSiteURL();
+      return scoped_ptr<const HostID>(new HostID(HostID::WEBUI, url.spec()));
+    }
+  }
+  NOTREACHED();
+  return scoped_ptr<const HostID>();
+}
+
+bool Parse(const ContentScriptDetails& script_value,
+           UserScript* script,
+           extensions::WebViewGuest* guest,
+           const extensions::Extension* extension) {
+  // matches (required):
+  const std::vector<std::string>& matches = script_value.matches;
+  if (matches.size() == 0) {
+    return false;
+  }
+
+  for (const std::string& match : matches) {
+    URLPattern pattern(UserScript::ValidUserScriptSchemes(
+        true /* canExecuteScriptEverywhere*/));
+    if (pattern.Parse(match) != URLPattern::PARSE_SUCCESS)
+      return false;
+    script->add_url_pattern(pattern);
+  }
+
+  // exclude_matches:
+  if (script_value.exclude_matches) {
+    const std::vector<std::string>& exclude_matches =
+        *(script_value.exclude_matches.get());
+    for (const std::string& exclude_match : exclude_matches) {
+      URLPattern pattern(UserScript::ValidUserScriptSchemes(
+          true /* canExecuteScriptEverywhere*/));

[Fady Samuel, 2015/03/04 02:02:10]

Use unix_hacker style.

[Xi Han, 2015/03/06 17:29:07]

Done.

+
+      if (pattern.Parse(exclude_match) != URLPattern::PARSE_SUCCESS)
+        return false;
+      script->add_exclude_url_pattern(pattern);
+    }
+  }
+  // run_at:
+  if (script_value.run_at) {
+    UserScript::RunLocation run_at = UserScript::UNDEFINED;
+    switch (script_value.run_at) {
+      case ContentScriptDetails::RUN_AT_NONE:
+      case ContentScriptDetails::RUN_AT_DOCUMENT_IDLE:
+        run_at = UserScript::DOCUMENT_IDLE;
+        break;
+      case ContentScriptDetails::RUN_AT_DOCUMENT_START:
+        run_at = UserScript::DOCUMENT_START;
+        break;
+      case ContentScriptDetails::RUN_AT_DOCUMENT_END:
+        run_at = UserScript::DOCUMENT_END;
+        break;
+    }
+    script->set_run_location(run_at);
+  }
+
+  // match_about_blank
+  if (script_value.match_about_blank)
+    script->set_match_about_blank(*script_value.match_about_blank);
+
+  GURL owner_base_url(guest->GetOwnerSiteURL().GetWithEmptyPath());
+
+  // css:
+  if (script_value.css) {
+    const std::vector<std::string>& css_files = *(script_value.css.get());
+    for (const std::string& relative : css_files) {
+      GURL url = owner_base_url.Resolve(relative);
+      if (extension) {
+        ExtensionResource resource = extension->GetResource(relative);
+        script->css_scripts().push_back(UserScript::File(
+            resource.extension_root(), resource.relative_path(), url));
+      } else {
+        script->css_scripts().push_back(extensions::UserScript::File(
+            base::FilePath(), base::FilePath(), url));
+      }
+    }
+  }
+
+  // js:
+  if (script_value.js) {
+    const std::vector<std::string>& js_files = *(script_value.js.get());
+    for (const std::string& relative: js_files) {
+      GURL url = owner_base_url.Resolve(relative);
+      if (extension) {
+        ExtensionResource resource = extension->GetResource(relative);
+        script->js_scripts().push_back(UserScript::File(
+            resource.extension_root(), resource.relative_path(), url));
+      } else {
+        script->js_scripts().push_back(extensions::UserScript::File(
+            base::FilePath(), base::FilePath(), url));
+      }
+    }
+  }
+
+  // all_frames:
+  if (script_value.all_frames) {
+    script->set_match_all_frames(*(script_value.all_frames));
+  }
+
+  // include_globs:

[Fady Samuel, 2015/03/04 02:02:10]

Remind me what these are?

[Xi Han, 2015/03/06 17:29:07]

Include_globs can be used to limit which pages are affected after "matches".
Only the urls that match the pattern defined in "matches" and "include_globs"
will be affected. 
https://developer.chrome.com/extensions/content_scripts#match-patterns-globs

+  if (script_value.include_globs) {
+    const std::vector<std::string>& include_globs =
+        *(script_value.include_globs.get());
+    for (const std::string& glob: include_globs)
+      script->add_glob(glob);
+  }
+
+  // exclude_globs:

[Fady Samuel, 2015/03/04 02:02:10]

Same here. What is this?

[Xi Han, 2015/03/06 17:29:07]

Applied after "matches" to exclude URLs that match this glob. 

+  if (script_value.exclude_globs) {
+    const auto& exclude_globs = *(script_value.exclude_globs.get());
+    for (const std::string& glob: exclude_globs)
+      script->add_exclude_glob(glob);
+  }
+  return true;
+}
+
 }  // namespace
 
 namespace extensions {
 
 bool WebViewInternalExtensionFunction::RunAsync() {
   int instance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &instance_id));
   WebViewGuest* guest = WebViewGuest::From(
       render_view_host()->GetProcess()->GetID(), instance_id);
   if (!guest)
@@ skipping 88 matching lines @@
       error, on_url, result);
 }
 
 WebViewInternalInsertCSSFunction::WebViewInternalInsertCSSFunction() {
 }
 
 bool WebViewInternalInsertCSSFunction::ShouldInsertCSS() const {
   return true;
 }
 
+WebViewInternalAddContentScriptsFunction::
+WebViewInternalAddContentScriptsFunction() {
+}
+
+WebViewInternalAddContentScriptsFunction::
+~WebViewInternalAddContentScriptsFunction() {
+}
+
+bool WebViewInternalAddContentScriptsFunction::RunAsyncSafe(
+    WebViewGuest* guest) {
+  scoped_ptr<webview::AddContentScripts::Params> params(
+      webview::AddContentScripts::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  auto script_list = params->content_script_list;
+  if (guest->IsHostIDEmpty())
+    guest->set_host_id(GenerateHostID(extension(), render_view_host()));
+
+  for (size_t i = 0; i < script_list.size(); ++i) {
+    const ContentScriptDetails& script_value = *script_list[i];
+    const std::string& name = script_value.name;
+    UserScript script;
+    if (Parse(script_value, &script, guest, extension())) {
+      script.set_id(UserScript::GenerateUserScriptID());
+      script.set_host_id(guest->host_id());
+      guest->AddContentScripts(name, script);
+    } else {
+      SendResponse(false);
+      return false;
+    }
+  }
+  SendResponse(true);
+  return true;
+}
+
+WebViewInternalRemoveContentScriptsFunction::
+WebViewInternalRemoveContentScriptsFunction() {
+}
+
+WebViewInternalRemoveContentScriptsFunction::
+~WebViewInternalRemoveContentScriptsFunction() {
+}
+
+bool WebViewInternalRemoveContentScriptsFunction::RunAsyncSafe(
+    WebViewGuest* guest) {
+  scoped_ptr<webview::RemoveContentScripts::Params> params(
+      webview::RemoveContentScripts::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  if (!params->script_name_list) {
+    guest->RemoveAllContentScripts();
+  } else {
+    for (const std::string& name: *params->script_name_list)
+      guest->RemoveContentScripts(name);
+  }
+  SendResponse(true);
+  return true;
+}
 WebViewInternalSetNameFunction::WebViewInternalSetNameFunction() {
 }
 
 WebViewInternalSetNameFunction::~WebViewInternalSetNameFunction() {
 }
 
 bool WebViewInternalSetNameFunction::RunAsyncSafe(WebViewGuest* guest) {
   scoped_ptr<webview::SetName::Params> params(
       webview::SetName::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ skipping 344 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void WebViewInternalClearDataFunction::ClearDataDone() {
   Release();  // Balanced in RunAsync().
   SendResponse(true);
 }
 
 }  // namespace extensions