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

extensions/browser/api/guest_view/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/guest_view/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/browser_context.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 "content/public/common/stop_find_action.h"
 #include "content/public/common/url_fetcher.h"
 #include "extensions/browser/guest_view/web_view/web_view_constants.h"
 #include "extensions/browser/guest_view/web_view/web_view_content_script_manager.h"
 #include "extensions/common/api/web_view_internal.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/user_script.h"
-#include "net/base/load_flags.h"
-#include "net/url_request/url_fetcher.h"
-#include "net/url_request/url_fetcher_delegate.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 
 using content::WebContents;
 using extensions::ExtensionResource;
 using extensions::core_api::web_view_internal::ContentScriptDetails;
 using extensions::core_api::web_view_internal::SetPermission::Params;
 using extensions::core_api::extension_types::InjectDetails;
 using extensions::UserScript;
 using ui_zoom::ZoomController;
 // error messages for content scripts:
@@ skipping 193 matching lines @@
     script.set_consumer_instance_type(UserScript::WEBVIEW);
     result->insert(script);
   }
   return true;
 }
 
 }  // namespace
 
 namespace extensions {
 
-// WebUIURLFetcher downloads the content of a file by giving its |url| on WebUI.
-// Each WebUIURLFetcher is associated with a given |render_process_id,
-// render_view_id| pair.
-class WebViewInternalExecuteCodeFunction::WebUIURLFetcher
-    : public net::URLFetcherDelegate {
- public:
-  WebUIURLFetcher(
-      content::BrowserContext* context,
-      const WebViewInternalExecuteCodeFunction::WebUILoadFileCallback& callback)
-      : context_(context), callback_(callback) {}
-  ~WebUIURLFetcher() override {}
-
-  void Start(int render_process_id, int render_view_id, const GURL& url) {
-    fetcher_.reset(net::URLFetcher::Create(url, net::URLFetcher::GET, this));
-    fetcher_->SetRequestContext(context_->GetRequestContext());
-    fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
-
-    content::AssociateURLFetcherWithRenderFrame(
-        fetcher_.get(), url, render_process_id, render_view_id);
-    fetcher_->Start();
-  }
-
- private:
-  // net::URLFetcherDelegate:
-  void OnURLFetchComplete(const net::URLFetcher* source) override {
-    CHECK_EQ(fetcher_.get(), source);
-
-    std::string data;
-    bool result = false;
-    if (fetcher_->GetStatus().status() == net::URLRequestStatus::SUCCESS) {
-      result = fetcher_->GetResponseAsString(&data);
-      DCHECK(result);
-    }
-    fetcher_.reset();
-    callback_.Run(result, data);
-    callback_.Reset();
-  }
-
-  content::BrowserContext* context_;
-  WebViewInternalExecuteCodeFunction::WebUILoadFileCallback callback_;
-  scoped_ptr<net::URLFetcher> fetcher_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebUIURLFetcher);
-};
-
 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)
     return false;
 
   return RunAsyncSafe(guest);
 }
@@ skipping 78 matching lines @@
 bool WebViewInternalExecuteCodeFunction::IsWebView() const {
   return true;
 }
 
 const GURL& WebViewInternalExecuteCodeFunction::GetWebViewSrc() const {
   return guest_src_;
 }
 
 bool WebViewInternalExecuteCodeFunction::LoadFileForWebUI(
     const std::string& file_src,
-    const WebUILoadFileCallback& callback) {
+    const WebUIURLFetcher::WebUILoadFileCallback& callback) {
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
   WebViewGuest* guest = WebViewGuest::From(
       render_view_host()->GetProcess()->GetID(), guest_instance_id_);
   if (!guest || host_id().type() != HostID::WEBUI)
     return false;
 
   GURL owner_base_url(guest->GetOwnerSiteURL().GetWithEmptyPath());
   GURL file_url(owner_base_url.Resolve(file_src));
 
-  url_fetcher_.reset(new WebUIURLFetcher(this->browser_context(), callback));
-  url_fetcher_->Start(render_view_host()->GetProcess()->GetID(),
-                      render_view_host()->GetRoutingID(), file_url);
+  AddRef();
+  url_fetcher_.reset(new WebUIURLFetcher(
+      this->browser_context(), render_view_host()->GetProcess()->GetID(),
+      render_view_host()->GetRoutingID(), file_url, callback));
+  url_fetcher_->Start();
   return true;
 }
 
 bool WebViewInternalExecuteCodeFunction::LoadFile(const std::string& file) {
   if (!extension()) {
     if (LoadFileForWebUI(
             *details_->file,
             base::Bind(
                 &WebViewInternalExecuteCodeFunction::DidLoadAndLocalizeFile,
-                this, file)))
+                base::Unretained(this), file)))

[Devlin, 2015/04/21 22:32:20]

I think I liked this better the other way.  It's kind of silly to say AddRef()
and base::Unretained(), and it's easier to have the WebUIUrlFetcher just reset
the callback in all cases than to always make sure you don't have any refs
sitting around.

[Xi Han, 2015/04/22 15:32:10]

Ok, revert these changes.

       return true;
 
     SendResponse(false);
     error_ = ErrorUtils::FormatErrorMessage(kLoadFileError, file);
+    Release();
     return false;
   }
   return ExecuteCodeFunction::LoadFile(file);
 }
 
+void WebViewInternalExecuteCodeFunction::DidLoadAndLocalizeFile(
+    const std::string& file,
+    bool success,
+    const std::string& data) {
+  ExecuteCodeFunction::DidLoadAndLocalizeFile(file, success, data);
+  Release();
+}
+
 WebViewInternalExecuteScriptFunction::WebViewInternalExecuteScriptFunction() {
 }
 
 void WebViewInternalExecuteScriptFunction::OnExecuteCodeFinished(
     const std::string& error,
     const GURL& on_url,
     const base::ListValue& result) {
   if (error.empty())
     SetResult(result.DeepCopy());
   WebViewInternalExecuteCodeFunction::OnExecuteCodeFinished(
@@ skipping 33 matching lines @@
   bool incognito_enabled = browser_context()->IsOffTheRecord();
 
   if (!ParseContentScripts(params->content_script_list, extension(), host_id,
                            incognito_enabled, owner_base_url, &result, &error_))
     return RespondNow(Error(error_));
 
   WebViewContentScriptManager* manager =
       WebViewContentScriptManager::Get(browser_context());
   DCHECK(manager);
 
-  manager->AddContentScripts(sender_web_contents, params->instance_id, host_id,
-                             result);
+  manager->AddContentScripts(sender_web_contents,
+                             render_view_host()->GetRoutingID(),
+                             params->instance_id, host_id, result);
 
   return RespondNow(NoArguments());
 }
 
 WebViewInternalRemoveContentScriptsFunction::
     WebViewInternalRemoveContentScriptsFunction() {
 }
 
 WebViewInternalRemoveContentScriptsFunction::
     ~WebViewInternalRemoveContentScriptsFunction() {
@@ skipping 444 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void WebViewInternalClearDataFunction::ClearDataDone() {
   Release();  // Balanced in RunAsync().
   SendResponse(true);
 }
 
 }  // namespace extensions