filemanager: Add a browsertest for the sidebar item "Shared with Me".

chrome/browser/google_apis/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/google_apis/fake_drive_service.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 747 matching lines @@
                    GDATA_NO_CONNECTION,
                    base::Passed(&null)));
     return;
   }
 
   const char kContentType[] = "application/atom+xml;type=feed";
   const base::DictionaryValue* new_entry = AddNewEntry(kContentType,
                                                        0,  // content_length
                                                        parent_resource_id,
                                                        directory_name,
+                                                       false,  // shared_with_me
                                                        "folder");
   if (!new_entry) {
     scoped_ptr<ResourceEntry> null;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
     return;
   }
 
   scoped_ptr<ResourceEntry> parsed_entry(ResourceEntry::CreateFrom(*new_entry));
@@ skipping 18 matching lines @@
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return;
   }
 
   // Content length should be zero, as we'll create an empty file first. The
   // content will be added in ResumeUpload().
   const base::DictionaryValue* new_entry = AddNewEntry(content_type,
                                                        0,  // content_length
                                                        parent_resource_id,
                                                        title,
+                                                       false,  // shared_with_me
                                                        "file");
   if (!new_entry) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return;
   }
   const GURL upload_url = GetUploadUrl(*new_entry);
   DCHECK(upload_url.is_valid());
 
@@ skipping 158 matching lines @@
                                     const std::string& app_id,
                                     const AuthorizeAppCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 }
 
 void FakeDriveService::AddNewFile(const std::string& content_type,
                                   int64 content_length,
                                   const std::string& parent_resource_id,
                                   const std::string& title,
+                                  bool shared_with_me,
                                   const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<ResourceEntry> null;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    GDATA_NO_CONNECTION,
                    base::Passed(&null)));
     return;
   }
 
   // Prepare "kind" for hosted documents. This only supports Google Document.
   std::string entry_kind;
   if (content_type == "application/vnd.google-apps.document")
     entry_kind = "document";
   else
     entry_kind = "file";
 
   const base::DictionaryValue* new_entry = AddNewEntry(content_type,
                                                        content_length,
                                                        parent_resource_id,
                                                        title,
+                                                       shared_with_me,
                                                        entry_kind);
   if (!new_entry) {
     scoped_ptr<ResourceEntry> null;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
     return;
   }
 
   scoped_ptr<ResourceEntry> parsed_entry(
@@ skipping 131 matching lines @@
   ++largest_changestamp_;
   entry->SetString("docs$changestamp.value",
                    base::Int64ToString(largest_changestamp_));
 }
 
 const base::DictionaryValue* FakeDriveService::AddNewEntry(
     const std::string& content_type,
     int64 content_length,
     const std::string& parent_resource_id,
     const std::string& title,
+    bool shared_with_me,
     const std::string& entry_kind) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (parent_resource_id != GetRootResourceId() &&
       !FindEntryByResourceId(parent_resource_id)) {
     return NULL;
   }
 
   base::DictionaryValue* resource_list_dict = NULL;
   if (!resource_list_value_->GetAsDictionary(&resource_list_dict))
@@ skipping 16 matching lines @@
   }
 
   // Add "category" which sets the resource type to |entry_kind|.
   base::ListValue* categories = new base::ListValue;
   base::DictionaryValue* category = new base::DictionaryValue;
   category->SetString("scheme", "http://schemas.google.com/g/2005#kind");
   category->SetString("term", "http://schemas.google.com/docs/2007#" +
                       entry_kind);
   categories->Append(category);
   new_entry->Set("category", categories);
+  if (shared_with_me) {
+    base::DictionaryValue* shared_with_me_label = new base::DictionaryValue;
+    shared_with_me_label->SetString("label", "shared-with-me");
+    shared_with_me_label->SetString("scheme",
+                                    "http://schemas.google.com/g/2005/labels");
+    shared_with_me_label->SetString(
+        "term", "http://schemas.google.com/g/2005/labels#shared");
+    categories->Append(shared_with_me_label);
+  }
 
   // Add "content" which sets the content URL.
   base::DictionaryValue* content = new base::DictionaryValue;
   content->SetString("src", "https://xxx/content/" + resource_id);
   content->SetString("type", content_type);
   new_entry->Set("content", content);
 
   // Add "link" which sets the parent URL, the edit URL and the upload URL.
   base::ListValue* links = new base::ListValue;
 
@@ skipping 137 matching lines @@
 
   ++resource_list_load_count_;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(&resource_list)));
 }
 
 }  // namespace google_apis