Avoid HTML in WebRestrictionsContentProvider interface

components/web_restrictions/browser/web_restrictions_client.cc

 // Copyright 2015 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 "components/web_restrictions/browser/web_restrictions_client.h"
 
 #include "base/android/jni_string.h"
-#include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/public/browser/browser_thread.h"
 #include "jni/WebRestrictionsClient_jni.h"
 
+using base::android::ScopedJavaGlobalRef;
+
 namespace web_restrictions {
 
 namespace {
 
 const size_t kMaxCacheSize = 100;
 
 bool RequestPermissionTask(
     const GURL& url,
     const base::android::JavaRef<jobject>& java_provider) {
   JNIEnv* env = base::android::AttachCurrentThread();
@@ skipping 63 matching lines @@
                  base::Unretained(this), provider_authority_));
 }
 
 UrlAccess WebRestrictionsClient::ShouldProceed(
     bool is_main_frame,
     const GURL& url,
     const base::Callback<void(bool)>& callback) {
   DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
   if (!initialized_)
     return ALLOW;
-  auto iter = url_access_cache_.find(url);
-  if (iter != url_access_cache_.end()) {
+  auto iter = cache_.find(url);
+  if (iter != cache_.end()) {
     RecordURLAccess(url);
-    return iter->second ? ALLOW : DISALLOW;
+    JNIEnv* env = base::android::AttachCurrentThread();
+    return Java_ShouldProceedResult_shouldProceed(env, iter->second.obj())
+               ? ALLOW
+               : DISALLOW;
   }
   base::PostTaskAndReplyWithResult(
       background_task_runner_.get(), FROM_HERE,
       base::Bind(&WebRestrictionsClient::ShouldProceedTask, url,
                  java_provider_),
       base::Bind(&WebRestrictionsClient::OnShouldProceedComplete,
                  base::Unretained(this), provider_authority_, url, callback));
 
   return PENDING;
 }
 
 bool WebRestrictionsClient::SupportsRequest() const {
   return initialized_ && supports_request_;
 }
 
-bool WebRestrictionsClient::GetErrorHtml(const GURL& url,
-                                         std::string* error_page) const {
+int WebRestrictionsClient::GetResultColumnCount(const GURL& url) const {
   DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
   if (!initialized_)
-    return false;
-  auto iter = error_page_cache_.find(url);
-  if (iter == error_page_cache_.end())
-    return false;
-  *error_page = iter->second;
-  return true;
+    return 0;
+  auto iter = cache_.find(url);
+  if (iter == cache_.end())
+    return 0;
+  return Java_ShouldProceedResult_getColumnCount(
+      base::android::AttachCurrentThread(), iter->second.obj());
+}
+
+std::string WebRestrictionsClient::GetResultColumnName(const GURL& url,
+                                                       int column) const {
+  DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
+  if (!initialized_)
+    return 0;

[Bernhard Bauer, 2016/03/31 10:09:07]

How can you return an int in a method that is supposed to return a std::string?

[aberent, 2016/03/31 11:53:58]

Done.

+  auto iter = cache_.find(url);
+  if (iter == cache_.end())
+    return 0;
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+  return base::android::ConvertJavaStringToUTF8(
+      env,
+      Java_ShouldProceedResult_getColumnName(env, iter->second.obj(), column)
+          .obj());
+}
+
+int WebRestrictionsClient::GetResultIntValue(const GURL& url,
+                                             int column) const {
+  DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
+  if (!initialized_)
+    return 0;
+  auto iter = cache_.find(url);
+  if (iter == cache_.end())
+    return 0;
+  return Java_ShouldProceedResult_getInt(base::android::AttachCurrentThread(),
+                                         iter->second.obj(), column);
+}
+
+std::string WebRestrictionsClient::GetResultStringValue(const GURL& url,
+                                                        int column) const {
+  DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
+  if (!initialized_)
+    return 0;
+  auto iter = cache_.find(url);
+  if (iter == cache_.end())
+    return 0;
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+  return base::android::ConvertJavaStringToUTF8(
+      env, Java_ShouldProceedResult_getString(env, iter->second.obj(), column)
+               .obj());
 }
 
 void WebRestrictionsClient::RequestPermission(
     const GURL& url,
     const base::Callback<void(bool)>& request_success) {
   if (!initialized_) {
     request_success.Run(false);
     return;
   }
   base::PostTaskAndReplyWithResult(
       background_task_runner_.get(), FROM_HERE,
       base::Bind(&RequestPermissionTask, url, java_provider_), request_success);
 }
 
 void WebRestrictionsClient::OnWebRestrictionsChanged() {
   single_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WebRestrictionsClient::ClearCache, base::Unretained(this)));
 }
 
 void WebRestrictionsClient::RecordURLAccess(const GURL& url) {
   DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
   // Move the URL to the front of the cache.
   recent_urls_.remove(url);
   recent_urls_.push_front(url);
 }
 
 void WebRestrictionsClient::UpdateCache(std::string provider_authority,
                                         GURL url,
-                                        bool should_proceed,
-                                        std::string error_page) {
+                                        ScopedJavaGlobalRef<jobject> result) {
   DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
   // If the webrestrictions provider changed when the old one was being queried,
   // do not update the cache for the new provider.
   if (provider_authority != provider_authority_)
     return;
   RecordURLAccess(url);
   if (recent_urls_.size() >= kMaxCacheSize) {
-    url_access_cache_.erase(recent_urls_.back());
-    error_page_cache_.erase(recent_urls_.back());
+    cache_.erase(recent_urls_.back());
     recent_urls_.pop_back();
   }
-  url_access_cache_[url] = should_proceed;
-  if (!error_page.empty()) {
-    error_page_cache_[url] = error_page;
-  } else {
-    error_page_cache_.erase(url);
-  }
+  cache_[url] = result;
 }
 
 void WebRestrictionsClient::RequestSupportKnown(std::string provider_authority,
                                                 bool supports_request) {
   // |supports_request_| is initialized to false.
   DCHECK(!supports_request_);
   DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
   // If the webrestrictions provider changed when the old one was being queried,
   // ignore the result.
   if (provider_authority != provider_authority_)
     return;
   supports_request_ = supports_request;
 }
 
 void WebRestrictionsClient::OnShouldProceedComplete(
     std::string provider_authority,
     const GURL& url,
     const base::Callback<void(bool)>& callback,
-    const ShouldProceedResult& result) {
-  UpdateCache(provider_authority, url, result.ok_to_proceed, result.error_page);
-  callback.Run(result.ok_to_proceed);
+    const ScopedJavaGlobalRef<jobject>& result) {
+  UpdateCache(provider_authority, url, result);
+  JNIEnv* env = base::android::AttachCurrentThread();
+  callback.Run(Java_ShouldProceedResult_shouldProceed(env, result.obj()));
 }
 
 void WebRestrictionsClient::ClearCache() {
   DCHECK(single_thread_task_runner_->BelongsToCurrentThread());
-  error_page_cache_.clear();
-  url_access_cache_.clear();
+  cache_.clear();
   recent_urls_.clear();
 }
 
 // static
-WebRestrictionsClient::ShouldProceedResult
-WebRestrictionsClient::ShouldProceedTask(
+ScopedJavaGlobalRef<jobject> WebRestrictionsClient::ShouldProceedTask(
     const GURL& url,
     const base::android::JavaRef<jobject>& java_provider) {
-  WebRestrictionsClient::ShouldProceedResult result;
   JNIEnv* env = base::android::AttachCurrentThread();
-  base::android::ScopedJavaLocalRef<jobject> j_result =
+  base::android::ScopedJavaGlobalRef<jobject> result(
       Java_WebRestrictionsClient_shouldProceed(
           env, java_provider.obj(),
-          base::android::ConvertUTF8ToJavaString(env, url.spec()).obj());
-  result.ok_to_proceed =
-      Java_ShouldProceedResult_shouldProceed(env, j_result.obj());
-  base::android::ScopedJavaLocalRef<jstring> j_error_page =
-      Java_ShouldProceedResult_getErrorPage(env, j_result.obj());
-  if (!j_error_page.is_null()) {
-    base::android::ConvertJavaStringToUTF8(env, j_error_page.obj(),
-                                           &result.error_page);
-  }
+          base::android::ConvertUTF8ToJavaString(env, url.spec()).obj()));
   return result;
 }
 
 void NotifyWebRestrictionsChanged(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& clazz,
     jlong provider_ptr) {
   WebRestrictionsClient* provider =
       reinterpret_cast<WebRestrictionsClient*>(provider_ptr);
   // TODO(knn): Also reload existing interstitials/error pages.
   provider->OnWebRestrictionsChanged();
 }
 
 }  // namespace web_restrictions