Implement Web Restrictions in WebView.

components/web_restrictions/browser/web_restrictions_client.h

 // 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.
 
 #ifndef COMPONENTS_WEB_RESTRICTION_WEB_RESTRICTIONS_CLIENT_H_
 #define COMPONENTS_WEB_RESTRICTION_WEB_RESTRICTIONS_CLIENT_H_
 
 #include <jni.h>
+
 #include <list>
-#include <map>
 #include <string>
+#include <unordered_map>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
-#include "url/gurl.h"
+#include "base/synchronization/lock.h"
+#include "components/web_restrictions/browser/web_restictions_client_result.h"
+
+namespace base {
+class Lock;

[Bernhard Bauer, 2016/04/18 14:48:34]

You already include the header for this.

[aberent, 2016/05/18 20:06:51]

Done.

+}
 
 namespace web_restrictions {
 
 enum UrlAccess { ALLOW, DISALLOW, PENDING };
 
+class WebRestrictionsCache {

[Bernhard Bauer, 2016/04/18 14:48:35]

Can't this be inside of WebRestrictionsClient?

[aberent, 2016/05/18 20:06:51]

Done.

+ public:
+  std::unique_ptr<const WebRestrictionsClientResult> GetCacheEntry(

[Bernhard Bauer, 2016/04/18 14:48:34]

The const seems a bit much. If a client gets a fresh copy, they can do with it
what they want anyway, and there aren't even any non-const methods on this
class, so it's not like we avoid accidental mutation.

[aberent, 2016/05/18 20:06:50]

Done.

+      const std::string& url);
+  void SetCacheEntry(const std::string& url,
+                     const WebRestrictionsClientResult& entry);
+  void RemoveCacheEntry(const std::string& url);
+  void Clear();
+
+ private:
+  base::Lock lock_;
+  std::unordered_map<std::string, WebRestrictionsClientResult> cache_data_;

[Bernhard Bauer, 2016/04/18 14:48:35]

DISALLOW_COPY_AND_ASSIGN?

[aberent, 2016/05/18 20:06:51]

Done.

+};
+
 class WebRestrictionsClient {
  public:
   // An instance of this class is expected to live through the lifetime of a
   // browser and uses raw pointers in callbacks.
   // Any changes to the class, enable/disable/change should be done through the
   // SetAuthority(...) method.
   WebRestrictionsClient();
   ~WebRestrictionsClient();
 
   // Register JNI methods.
   static bool Register(JNIEnv* env);
 
   // Verify the content provider and query it for basic information like does it
   // support handling requests. This should be called everytime the provider
   // changes. An empty authority can be used to disable this class.
   void SetAuthority(const std::string& content_provider_authority);
 
   // WebRestrictionsProvider:
   UrlAccess ShouldProceed(bool is_main_frame,
-                          const GURL& url,
+                          const std::string& url,

[Bernhard Bauer, 2016/04/18 14:48:34]

Why the change to std::string? I would use a GURL for as long as possible (i.e.
only stringify it right before going to Java).

[aberent, 2016/05/18 20:06:50]

For consistency the methods should all take the same type (string or GURL) for
the url. The Mojo interface requires a string, so I want
GetCachedWebRestrictions and RequestPermission to take strings. If I use a GURL
throughout I do a lot of conversion between strings and GURLs both here and in
the Mojo interface, whereas if I use a string throughout this class a conversion
is only needed in the caller.

Using a string internally also means that I can use std::unordered_map for the
cache without having to define a hash function for GURLs.

                           const base::Callback<void(bool)>& callback);
 
   bool SupportsRequest() const;
 
-  int GetResultColumnCount(const GURL& url) const;
-
-  std::string GetResultColumnName(const GURL& url, int column) const;
-
-  int GetResultIntValue(const GURL& url, int column) const;
-
-  std::string GetResultStringValue(const GURL& url, int column) const;
-
-  void RequestPermission(const GURL& url,
+  void RequestPermission(const std::string& url,
                          const base::Callback<void(bool)>& callback);
 
   void OnWebRestrictionsChanged();
 
+  // Get a cached WebRestrictionsResult synchronously, for use when building
+  // error pages etc.. May be called on any thread, and will return a fresh copy
+  // of the result (hence thread safe).
+  std::unique_ptr<const WebRestrictionsClientResult>
+  GetCachedWebRestrictionsResult(const std::string& url);
+
  private:
+  void SetAuthorityTask(const std::string& content_provider_authority);
 
-  void RecordURLAccess(const GURL& url);
+  void RecordURLAccess(const std::string& url);
 
   void UpdateCache(std::string provider_authority,
-                   GURL url,
+                   std::string url,
                    base::android::ScopedJavaGlobalRef<jobject> result);
 
   void RequestSupportKnown(std::string provider_authority,
                            bool supports_request);
 
   void ClearCache();
 
   static base::android::ScopedJavaGlobalRef<jobject> ShouldProceedTask(
-      const GURL& url,
+      const std::string& url,
       const base::android::JavaRef<jobject>& java_provider);
 
   void OnShouldProceedComplete(
       std::string provider_authority,
-      const GURL& url,
+      const std::string& url,
       const base::Callback<void(bool)>& callback,
       const base::android::ScopedJavaGlobalRef<jobject>& result);
 
   // Set up after SetAuthority().
   bool initialized_;
   bool supports_request_;
   base::android::ScopedJavaGlobalRef<jobject> java_provider_;
   std::string provider_authority_;
+  WebRestrictionsCache cache_;
 
   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> single_thread_task_runner_;
-
-  std::map<GURL, base::android::ScopedJavaGlobalRef<jobject>> cache_;
-  std::list<GURL> recent_urls_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner_;
+  std::list<std::string> recent_urls_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRestrictionsClient);
 };
 
 }  // namespace web_restrictions
 
 #endif  // COMPONENTS_WEB_RESTRICTION_WEB_RESTRICTIONS_CLIENT_H_