Enable <webview>.executeScript outside of Apps and Extensions [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/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/storage_partition.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/common/api/web_view_internal.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::core_api::web_view_internal::SetPermission::Params;
 using extensions::core_api::extension_types::InjectDetails;
+using net::URLFetcher;
 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";
@@ skipping 12 matching lines @@
     return content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
   if (strcmp(key, kWebSQLKey) == 0)
     return content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
   return 0;
 }
 
 }  // 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(scoped_refptr<WebViewInternalExecuteCodeFunction> function,
+                  const GURL& url,
+                  int render_process_id,
+                  int render_view_id,
+                  const ExecuteCodeFunction::WebUILoadFileCallback& callback)
+      : function_(function),
+        url_(url),
+        render_process_id_(render_process_id),
+        render_view_id_(render_view_id),
+        callback_(callback) {}
+  ~WebUIURLFetcher() override {}
+
+  void Start() {
+    fetcher_.reset(URLFetcher::Create(url_, URLFetcher::GET, this));
+    fetcher_->SetRequestContext(
+        function_->browser_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 URLFetcher* source) override {
+    CHECK_EQ(fetcher_.get(), source);
+    scoped_ptr<net::URLFetcher> fetcher(fetcher_.Pass());
+
+    std::string data;
+    if (fetcher->GetStatus().status() != net::URLRequestStatus::SUCCESS ||
+        fetcher->GetResponseCode() != 200) {
+      function_->OnWebUIURLFetchComplete(this, false, data);
+      callback_.Run(false, data);
+      return;
+    }
+
+    bool result = fetcher->GetResponseAsString(&data);
+    DCHECK(result) << "Invalid fethcer setting.";

[Fady Samuel, 2015/03/16 21:07:09]

typo: fetcher

[Xi Han, 2015/03/17 16:12:47]

Done.

+    callback_.Run(true, data);
+  }
+
+  scoped_refptr<WebViewInternalExecuteCodeFunction> function_;
+  GURL url_;
+  const int render_process_id_;
+  const int render_view_id_;
+  const ExecuteCodeFunction::WebUILoadFileCallback callback_;
+  scoped_ptr<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 76 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) {
+  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));
+
+  WebUIURLFetcher* fetcher =

[Fady Samuel, 2015/03/16 21:07:09]

Make scoped_ptr?

[Xi Han, 2015/03/17 16:12:47]

Since fetcher->start() is a async call, so we need to store fetcher in
somewhere, and call fetcher.start(). ScopedVector can take care of raw pointer
and delete them when its deconstructor is called. At the same time, we can still
call fethcer->start().

If use scoped_ptr, then fethcer won't own the raw pointer anymore after passing
the ownership to the fetchers.

+      new WebUIURLFetcher(make_scoped_refptr(this), file_url,
+                          render_view_host()->GetProcess()->GetID(),
+                          render_view_host()->GetRoutingID(), callback);
+  fetchers_.push_back(fetcher);
+  fetcher->Start();
+  return true;
+}
+
+void WebViewInternalExecuteCodeFunction::OnWebUIURLFetchComplete(
+    const WebUIURLFetcher* fetcher,
+    bool is_success,
+    std::string data) {
+  fetchers_.erase(std::find(fetchers_.begin(), fetchers_.end(), fetcher));
+}
+
 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 364 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void WebViewInternalClearDataFunction::ClearDataDone() {
   Release();  // Balanced in RunAsync().
   SendResponse(true);
 }
 
 }  // namespace extensions