android_webview/native/permission/permission_request_handler_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "android_webview/native/permission/aw_permission_request.h"
   6 #include "android_webview/native/permission/aw_permission_request_delegate.h"
   7 #include "android_webview/native/permission/permission_request_handler.h"
   8 #include "android_webview/native/permission/permission_request_handler_client.h"
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace android_webview {
  14
  15 class TestAwPermissionRequestDelegate : public AwPermissionRequestDelegate {
  16  public:
  17   TestAwPermissionRequestDelegate(
  18       const GURL& origin, int64 resources, base::Callback<void(bool)> callback)
  19       : origin_(origin),
  20         resources_(resources),
  21         callback_(callback) {}
  22
  23   // Get the origin which initiated the permission request.
  24   const GURL& GetOrigin() override { return origin_; }
  25
  26   // Get the resources the origin wanted to access.
  27   int64 GetResources() override { return resources_; }
  28
  29   // Notify the permission request is allowed or not.
  30   void NotifyRequestResult(bool allowed) override { callback_.Run(allowed); }
  31
  32  private:
  33   GURL origin_;
  34   int64 resources_;
  35   base::Callback<void(bool)> callback_;
  36 };
  37
  38 class TestPermissionRequestHandlerClient :
  39       public PermissionRequestHandlerClient {
  40  public:
  41   struct Permission {
  42     Permission()
  43         :resources(0) {}
  44     Permission(const GURL& origin, int64 resources)
  45         : origin(origin),
  46           resources(resources) {}
  47     GURL origin;
  48     int64 resources;
  49   };
  50
  51   TestPermissionRequestHandlerClient()
  52       : request_(NULL) {}
  53
  54   void OnPermissionRequest(AwPermissionRequest* request) override {
  55     request_ = request;
  56     requested_permission_ =
  57         Permission(request->GetOrigin(), request->GetResources());
  58   }
  59
  60   void OnPermissionRequestCanceled(AwPermissionRequest* request) override {
  61     canceled_permission_ =
  62         Permission(request->GetOrigin(), request->GetResources());
  63   }
  64
  65   AwPermissionRequest* request() {
  66     return request_;
  67   }
  68
  69   const Permission& requested_permission() {
  70     return requested_permission_;
  71   }
  72
  73   const Permission& canceled_permission() {
  74     return canceled_permission_;
  75   }
  76
  77   void Grant() {
  78     request_->OnAccept(NULL, NULL, true);
  79     request_ = NULL;
  80   }
  81
  82   void Deny() {
  83     request_->OnAccept(NULL, NULL, false);
  84     request_ = NULL;
  85   }
  86
  87   void Reset() {
  88     request_ = NULL;
  89     requested_permission_ = Permission();
  90     canceled_permission_ = Permission();
  91   }
  92
  93  private:
  94   AwPermissionRequest* request_;
  95   Permission requested_permission_;
  96   Permission canceled_permission_;
  97 };
  98
  99 class TestPermissionRequestHandler : public PermissionRequestHandler {
 100  public:
 101   TestPermissionRequestHandler(PermissionRequestHandlerClient* client)
 102       : PermissionRequestHandler(client, NULL) {
 103   }
 104
 105   const std::vector<base::WeakPtr<AwPermissionRequest> > requests() {
 106     return requests_;
 107   }
 108
 109   void PruneRequests() {
 110     return PermissionRequestHandler::PruneRequests();
 111   }
 112 };
 113
 114 class PermissionRequestHandlerTest : public testing::Test {
 115  public:
 116   PermissionRequestHandlerTest()
 117       : handler_(&client_),
 118         allowed_(false) {}
 119
 120   void NotifyRequestResult(bool allowed) {
 121     allowed_ = allowed;
 122   }
 123
 124  protected:
 125   void SetUp() override {
 126     testing::Test::SetUp();
 127     origin_ = GURL("http://www.google.com");
 128     resources_ =
 129         AwPermissionRequest::VideoCapture | AwPermissionRequest::AudioCapture;
 130     delegate_.reset(
 131         new TestAwPermissionRequestDelegate(
 132             origin_, resources_, base::Bind(
 133                 &PermissionRequestHandlerTest::NotifyRequestResult,
 134                 base::Unretained(this))));
 135   }
 136
 137   const GURL& origin() {
 138     return origin_;
 139   }
 140
 141   int64 resources() {
 142     return resources_;
 143   }
 144
 145   scoped_ptr<AwPermissionRequestDelegate> delegate() {
 146     return delegate_.Pass();
 147   }
 148
 149   TestPermissionRequestHandler* handler() {
 150     return  &handler_;
 151   }
 152
 153   TestPermissionRequestHandlerClient* client() {
 154     return &client_;
 155   }
 156
 157   bool allowed() {
 158     return allowed_;
 159   }
 160
 161  private:
 162   GURL origin_;
 163   int64 resources_;
 164   scoped_ptr<AwPermissionRequestDelegate> delegate_;
 165   TestPermissionRequestHandlerClient client_;
 166   TestPermissionRequestHandler handler_;
 167   bool allowed_;
 168 };
 169
 170 TEST_F(PermissionRequestHandlerTest, TestPermissionGranted) {
 171   handler()->SendRequest(delegate().Pass());
 172   // Verify Handler store the request correctly.
 173   ASSERT_EQ(1u, handler()->requests().size());
 174   EXPECT_EQ(origin(), handler()->requests()[0]->GetOrigin());
 175   EXPECT_EQ(resources(), handler()->requests()[0]->GetResources());
 176
 177   // Verify client's onPermissionRequest was called
 178   EXPECT_EQ(origin(), client()->request()->GetOrigin());
 179   EXPECT_EQ(resources(), client()->request()->GetResources());
 180
 181   // Simulate the grant request.
 182   client()->Grant();
 183   // Verify the request is notified as granted
 184   EXPECT_TRUE(allowed());
 185   handler()->PruneRequests();
 186   // Verify the weak reference in handler was removed.
 187   EXPECT_TRUE(handler()->requests().empty());
 188 }
 189
 190 TEST_F(PermissionRequestHandlerTest, TestPermissionDenied) {
 191   handler()->SendRequest(delegate().Pass());
 192   // Verify Handler store the request correctly.
 193   ASSERT_EQ(1u, handler()->requests().size());
 194   EXPECT_EQ(origin(), handler()->requests()[0]->GetOrigin());
 195   EXPECT_EQ(resources(), handler()->requests()[0]->GetResources());
 196
 197   // Verify client's onPermissionRequest was called
 198   EXPECT_EQ(origin(), client()->request()->GetOrigin());
 199   EXPECT_EQ(resources(), client()->request()->GetResources());
 200
 201   // Simulate the deny request.
 202   client()->Deny();
 203   // Verify the request is notified as granted
 204   EXPECT_FALSE(allowed());
 205   handler()->PruneRequests();
 206   // Verify the weak reference in handler was removed.
 207   EXPECT_TRUE(handler()->requests().empty());
 208 }
 209
 210 TEST_F(PermissionRequestHandlerTest, TestMultiplePermissionRequest) {
 211   GURL origin1 = GURL("http://a.google.com");
 212   int64 resources1 = AwPermissionRequest::Geolocation;
 213
 214   scoped_ptr<AwPermissionRequestDelegate> delegate1;
 215   delegate1.reset(new TestAwPermissionRequestDelegate(
 216       origin1, resources1,
 217       base::Bind(&PermissionRequestHandlerTest::NotifyRequestResult,
 218                  base::Unretained(this))));
 219
 220   // Send 1st request
 221   handler()->SendRequest(delegate().Pass());
 222   // Verify Handler store the request correctly.
 223   ASSERT_EQ(1u, handler()->requests().size());
 224   EXPECT_EQ(origin(), handler()->requests()[0]->GetOrigin());
 225   EXPECT_EQ(resources(), handler()->requests()[0]->GetResources());
 226   // Verify client's onPermissionRequest was called
 227   EXPECT_EQ(origin(), client()->request()->GetOrigin());
 228   EXPECT_EQ(resources(), client()->request()->GetResources());
 229
 230   // Send 2nd request
 231   handler()->SendRequest(delegate1.Pass());
 232   // Verify Handler store the request correctly.
 233   ASSERT_EQ(2u, handler()->requests().size());
 234   EXPECT_EQ(origin(), handler()->requests()[0]->GetOrigin());
 235   EXPECT_EQ(resources(), handler()->requests()[0]->GetResources());
 236   EXPECT_EQ(origin1, handler()->requests()[1]->GetOrigin());
 237   EXPECT_EQ(resources1, handler()->requests()[1]->GetResources());
 238   // Verify client's onPermissionRequest was called
 239   EXPECT_EQ(origin1, client()->request()->GetOrigin());
 240   EXPECT_EQ(resources1, client()->request()->GetResources());
 241
 242   // Send 3rd request which has same origin and resources as first one.
 243   delegate1.reset(new TestAwPermissionRequestDelegate(origin(), resources(),
 244       base::Bind(&PermissionRequestHandlerTest::NotifyRequestResult,
 245                  base::Unretained(this))));
 246   handler()->SendRequest(delegate1.Pass());
 247   // Verify Handler store the request correctly.
 248   ASSERT_EQ(3u, handler()->requests().size());
 249   EXPECT_EQ(origin(), handler()->requests()[0]->GetOrigin());
 250   EXPECT_EQ(resources(), handler()->requests()[0]->GetResources());
 251   EXPECT_EQ(origin1, handler()->requests()[1]->GetOrigin());
 252   EXPECT_EQ(resources1, handler()->requests()[1]->GetResources());
 253   EXPECT_EQ(origin(), handler()->requests()[2]->GetOrigin());
 254   EXPECT_EQ(resources(), handler()->requests()[2]->GetResources());
 255   // Verify client's onPermissionRequest was called
 256   EXPECT_EQ(origin(), client()->request()->GetOrigin());
 257   EXPECT_EQ(resources(), client()->request()->GetResources());
 258
 259   // Cancel the request.
 260   handler()->CancelRequest(origin(), resources());
 261   // Verify client's OnPermissionRequestCancled() was called.
 262   EXPECT_EQ(origin(), client()->canceled_permission().origin);
 263   EXPECT_EQ(resources(), client()->canceled_permission().resources);
 264   // Verify Handler store the request correctly, the 1st and 3rd were removed.
 265   handler()->PruneRequests();
 266   ASSERT_EQ(1u, handler()->requests().size());
 267   EXPECT_EQ(origin1, handler()->requests()[0]->GetOrigin());
 268   EXPECT_EQ(resources1, handler()->requests()[0]->GetResources());
 269 }
 270
 271 TEST_F(PermissionRequestHandlerTest, TestPreauthorizePermission) {
 272   handler()->PreauthorizePermission(origin(), resources());
 273
 274   // Permission should granted without asking PermissionRequestHandlerClient.
 275   handler()->SendRequest(delegate().Pass());
 276   EXPECT_TRUE(allowed());
 277   EXPECT_EQ(NULL, client()->request());
 278
 279   // Only ask one preauthorized resource, permission should granted
 280   // without asking PermissionRequestHandlerClient.
 281   scoped_ptr<AwPermissionRequestDelegate> delegate;
 282   delegate.reset(new TestAwPermissionRequestDelegate(
 283       origin(), AwPermissionRequest::AudioCapture,
 284       base::Bind(&PermissionRequestHandlerTest::NotifyRequestResult,
 285                  base::Unretained(this))));
 286   client()->Reset();
 287   handler()->SendRequest(delegate.Pass());
 288   EXPECT_TRUE(allowed());
 289   EXPECT_EQ(NULL, client()->request());
 290 }
 291
 292 TEST_F(PermissionRequestHandlerTest, TestOriginNotPreauthorized) {
 293   handler()->PreauthorizePermission(origin(), resources());
 294
 295   // Ask the origin which wasn't preauthorized.
 296   GURL origin ("http://a.google.com/a/b");
 297   scoped_ptr<AwPermissionRequestDelegate> delegate;
 298   int64 requested_resources = AwPermissionRequest::AudioCapture;
 299   delegate.reset(new TestAwPermissionRequestDelegate(
 300       origin, requested_resources,
 301       base::Bind(&PermissionRequestHandlerTest::NotifyRequestResult,
 302                  base::Unretained(this))));
 303   handler()->SendRequest(delegate.Pass());
 304   EXPECT_EQ(origin, handler()->requests()[0]->GetOrigin());
 305   EXPECT_EQ(requested_resources, handler()->requests()[0]->GetResources());
 306   client()->Grant();
 307   EXPECT_TRUE(allowed());
 308 }
 309
 310 TEST_F(PermissionRequestHandlerTest, TestResourcesNotPreauthorized) {
 311   handler()->PreauthorizePermission(origin(), resources());
 312
 313   // Ask the resources which weren't preauthorized.
 314   scoped_ptr<AwPermissionRequestDelegate> delegate;
 315   int64 requested_resources = AwPermissionRequest::AudioCapture
 316     | AwPermissionRequest::Geolocation;
 317   delegate.reset(new TestAwPermissionRequestDelegate(
 318       origin(), requested_resources,
 319       base::Bind(&PermissionRequestHandlerTest::NotifyRequestResult,
 320                  base::Unretained(this))));
 321
 322   handler()->SendRequest(delegate.Pass());
 323   EXPECT_EQ(origin(), handler()->requests()[0]->GetOrigin());
 324   EXPECT_EQ(requested_resources, handler()->requests()[0]->GetResources());
 325   client()->Deny();
 326   EXPECT_FALSE(allowed());
 327 }
 328
 329 TEST_F(PermissionRequestHandlerTest, TestPreauthorizeMultiplePermission) {
 330   handler()->PreauthorizePermission(origin(), resources());
 331   // Preauthorize another permission.
 332   GURL origin ("http://a.google.com/a/b");
 333   handler()->PreauthorizePermission(origin, AwPermissionRequest::Geolocation);
 334   GURL origin_hostname ("http://a.google.com/");
 335   scoped_ptr<AwPermissionRequestDelegate> delegate;
 336   delegate.reset(new TestAwPermissionRequestDelegate(
 337       origin_hostname, AwPermissionRequest::Geolocation,
 338       base::Bind(&PermissionRequestHandlerTest::NotifyRequestResult,
 339                  base::Unretained(this))));
 340   handler()->SendRequest(delegate.Pass());
 341   EXPECT_TRUE(allowed());
 342   EXPECT_EQ(NULL, client()->request());
 343 }
 344
 345 }  // android_webview