Add permission check to FakeDriveService

chrome/browser/drive/fake_drive_service.cc

 // Copyright (c) 2012 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 "chrome/browser/drive/fake_drive_service.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 32 matching lines @@
 using google_apis::FileResource;
 using google_apis::FileResourceCallback;
 using google_apis::GDATA_FILE_ERROR;
 using google_apis::GDATA_NO_CONNECTION;
 using google_apis::GDATA_OTHER_ERROR;
 using google_apis::GDataErrorCode;
 using google_apis::GetContentCallback;
 using google_apis::GetShareUrlCallback;
 using google_apis::HTTP_BAD_REQUEST;
 using google_apis::HTTP_CREATED;
+using google_apis::HTTP_FORBIDDEN;
 using google_apis::HTTP_NOT_FOUND;
 using google_apis::HTTP_NO_CONTENT;
 using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::InitiateUploadCallback;
 using google_apis::ParentReference;
 using google_apis::ProgressCallback;
 using google_apis::UploadRangeResponse;
 using google_apis::drive::UploadRangeCallback;
@@ skipping 61 matching lines @@
     file_list->set_next_link(change_list->next_link());
     for (size_t i = 0; i < change_list->items().size(); ++i) {
       const ChangeResource& entry = *change_list->items()[i];
       if (entry.file())
         file_list->mutable_items()->push_back(new FileResource(*entry.file()));
     }
   }
   callback.Run(error, file_list.Pass());
 }
 
+bool UserHasWriteAccess(google_apis::drive::PermissionRole user_permission) {
+  switch (user_permission) {
+    case google_apis::drive::PERMISSION_ROLE_OWNER:
+    case google_apis::drive::PERMISSION_ROLE_WRITER:
+      return true;
+    case google_apis::drive::PERMISSION_ROLE_READER:
+    case google_apis::drive::PERMISSION_ROLE_COMMENTER:
+      break;
+  }
+  return false;
+}
+
 }  // namespace
 
 struct FakeDriveService::EntryInfo {
+  EntryInfo() : user_permission(google_apis::drive::PERMISSION_ROLE_OWNER) {}
+
   google_apis::ChangeResource change_resource;
   GURL share_url;
   std::string content_data;
+
+  // Behaves in the same way as "userPermission" described in
+  // https://developers.google.com/drive/v2/reference/files
+  google_apis::drive::PermissionRole user_permission;
 };
 
 struct FakeDriveService::UploadSession {
   std::string content_type;
   int64 content_length;
   std::string parent_resource_id;
   std::string resource_id;
   std::string etag;
   std::string title;
 
@@ skipping 452 matching lines @@
           FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
       return CancelCallback();
     }
 
     if (!etag.empty() && etag != file->etag()) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(callback, HTTP_PRECONDITION));
       return CancelCallback();
     }
 
+    if (entry->user_permission != google_apis::drive::PERMISSION_ROLE_OWNER) {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(callback, HTTP_FORBIDDEN));
+      return CancelCallback();
+    }
+
     change->set_deleted(true);
     AddNewChangestamp(change);
     change->set_file(scoped_ptr<FileResource>());
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NO_CONTENT));
     return CancelCallback();
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
@@ skipping 12 matching lines @@
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (entry) {
     ChangeResource* change = &entry->change_resource;
     FileResource* file = change->mutable_file();
     GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
     if (change->is_deleted() || file->labels().is_trashed()) {
       error = HTTP_NOT_FOUND;
+    } else if (entry->user_permission !=
+               google_apis::drive::PERMISSION_ROLE_OWNER) {
+      error = HTTP_FORBIDDEN;
     } else {
       file->mutable_labels()->set_trashed(true);
       AddNewChangestamp(change);
       error = HTTP_SUCCESS;
     }
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, error));
     return CancelCallback();
   }
 
@@ skipping 153 matching lines @@
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION,
                               base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (entry) {
+    if (!UserHasWriteAccess(entry->user_permission)) {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(callback, HTTP_FORBIDDEN,
+                     base::Passed(scoped_ptr<FileResource>())));
+      return CancelCallback();
+    }
+
     ChangeResource* change = &entry->change_resource;
     FileResource* file = change->mutable_file();
 
     if (!new_title.empty())
       file->set_title(new_title);
 
     // Set parent if necessary.
     if (!parent_resource_id.empty()) {
       ParentReference parent;
       parent.set_file_id(parent_resource_id);
@@ skipping 166 matching lines @@
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return CancelCallback();
   }
 
+  if (!UserHasWriteAccess(entry->user_permission)) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, HTTP_FORBIDDEN, GURL()));
+    return CancelCallback();
+  }
+
   FileResource* file = entry->change_resource.mutable_file();
   if (!options.etag.empty() && options.etag != file->etag()) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_PRECONDITION, GURL()));
     return CancelCallback();
   }
   // TODO(hashimoto): Update |file|'s metadata with |options|.
 
   GURL session_url = GetNewUploadSessionUrl();
@@ skipping 296 matching lines @@
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   file->set_modified_date(last_modified_time);
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
                  base::Passed(make_scoped_ptr(new FileResource(*file)))));
 }
 
+google_apis::GDataErrorCode FakeDriveService::SetUserPermission(
+    const std::string& resource_id,
+    google_apis::drive::PermissionRole user_permission) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  EntryInfo* entry = FindEntryByResourceId(resource_id);
+  if (!entry)
+    return HTTP_NOT_FOUND;
+
+  entry->user_permission = user_permission;
+  return HTTP_SUCCESS;
+}
+
 FakeDriveService::EntryInfo* FakeDriveService::FindEntryByResourceId(
     const std::string& resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   EntryInfoMap::iterator it = entries_.find(resource_id);
   // Deleted entries don't have FileResource.
   return it != entries_.end() && it->second->change_resource.file() ?
       it->second : NULL;
 }
 
@@ skipping 228 matching lines @@
     google_apis::drive::PermissionRole role,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   NOTREACHED();
   return CancelCallback();
 }
 
 }  // namespace drive