[fsp] Show request logs in chrome://provided-file-systems.

chrome/browser/chromeos/file_system_provider/request_manager_unittest.cc

 // Copyright 2014 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
@@ skipping 139 matching lines @@
     explicit Event(int request_id) : request_id_(request_id) {}
     virtual ~Event() {}
     int request_id() const { return request_id_; }
 
    private:
     int request_id_;
   };
 
   class CreatedEvent : public Event {
    public:
-    CreatedEvent(int request_id, RequestManager::RequestType type)
+    CreatedEvent(int request_id, RequestType type)
         : Event(request_id), type_(type) {}
     virtual ~CreatedEvent() {}
 
-    RequestManager::RequestType type() const { return type_; }
+    RequestType type() const { return type_; }
 
    private:
-    RequestManager::RequestType type_;
+    RequestType type_;
   };
 
   class FulfilledEvent : public Event {
    public:
     FulfilledEvent(int request_id, bool has_more)
         : Event(request_id), has_more_(has_more) {}
     virtual ~FulfilledEvent() {}
 
     bool has_more() const { return has_more_; }
 
@@ skipping 10 matching lines @@
     base::File::Error error() const { return error_; }
 
    private:
     base::File::Error error_;
   };
 
   RequestObserver() {}
   virtual ~RequestObserver() {}
 
   // RequestManager::Observer overrides.
-  virtual void OnRequestCreated(int request_id,
-                                RequestManager::RequestType type) OVERRIDE {
+  virtual void OnRequestCreated(int request_id, RequestType type) OVERRIDE {
     created_.push_back(CreatedEvent(request_id, type));
   }
 
   // RequestManager::Observer overrides.
   virtual void OnRequestDestroyed(int request_id) OVERRIDE {
     destroyed_.push_back(Event(request_id));
   }
 
   // RequestManager::Observer overrides.
   virtual void OnRequestExecuted(int request_id) OVERRIDE {
@@ skipping 48 matching lines @@
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<RequestManager> request_manager_;
 };
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateFailure) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), false /* execute_reply */)));
 
   EXPECT_EQ(0, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   EXPECT_EQ(1u, observer.created().size());
-  EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+  EXPECT_EQ(TESTING, observer.created()[0].type());
   EXPECT_EQ(1u, observer.destroyed().size());
   EXPECT_EQ(0u, observer.executed().size());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
-  EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+  EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   scoped_ptr<RequestValue> response(
       RequestValue::CreateForTesting("i-like-vanilla"));
   const bool has_more = false;
 
   bool result =
       request_manager_->FulfillRequest(request_id, response.Pass(), has_more);
@@ skipping 37 matching lines @@
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
-  EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+  EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   scoped_ptr<RequestValue> response;
   const bool has_more = true;
 
   bool result =
       request_manager_->FulfillRequest(request_id, response.Pass(), has_more);
   EXPECT_TRUE(result);
@@ skipping 38 matching lines @@
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
-  EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+  EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
   bool result = request_manager_->RejectRequest(request_id, error);
   EXPECT_TRUE(result);
 
   // Validate if the callback has correct arguments.
   ASSERT_EQ(1u, logger.error_events().size());
@@ skipping 30 matching lines @@
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest,
        CreateAndFulfillWithWrongRequestId) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
-  EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+  EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   scoped_ptr<RequestValue> response;
   const bool has_more = true;
 
   const bool result = request_manager_->FulfillRequest(
       request_id + 1, response.Pass(), has_more);
   EXPECT_FALSE(result);
@@ skipping 16 matching lines @@
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest,
        CreateAndRejectWithWrongRequestId) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
-  EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+  EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
   bool result = request_manager_->RejectRequest(request_id + 1, error);
   EXPECT_FALSE(result);
 
   // Callbacks should not be called.
   EXPECT_EQ(0u, logger.error_events().size());
   EXPECT_EQ(0u, logger.success_events().size());
 
   EXPECT_EQ(0u, observer.rejected().size());
 
   // Confirm, that the request hasn't been removed, by rejecting it correctly.
   {
     bool retry = request_manager_->RejectRequest(request_id, error);
     EXPECT_TRUE(retry);
     EXPECT_EQ(1u, observer.rejected().size());
   }
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) {
   EventLogger logger;
 
   const int first_request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   const int second_request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, first_request_id);
   EXPECT_EQ(2, second_request_id);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, AbortOnDestroy) {
   EventLogger logger;
   RequestObserver observer;
   int request_id;
 
   {
     RequestManager request_manager;
     request_manager.AddObserver(&observer);
 
     request_id = request_manager.CreateRequest(
-        RequestManager::TESTING,
+        TESTING,
         make_scoped_ptr<RequestManager::HandlerInterface>(
             new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
     EXPECT_EQ(1, request_id);
     EXPECT_EQ(0u, logger.success_events().size());
     EXPECT_EQ(0u, logger.error_events().size());
 
     ASSERT_EQ(1u, observer.created().size());
     EXPECT_EQ(request_id, observer.created()[0].request_id());
-    EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+    EXPECT_EQ(TESTING, observer.created()[0].type());
 
     ASSERT_EQ(1u, observer.executed().size());
     EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
     EXPECT_EQ(0u, observer.fulfilled().size());
     EXPECT_EQ(0u, observer.rejected().size());
     EXPECT_EQ(0u, observer.destroyed().size());
     EXPECT_EQ(0u, observer.timeouted().size());
 
     // Do not remove the observer, to catch events while destructing.
@@ skipping 14 matching lines @@
   ASSERT_EQ(1u, observer.destroyed().size());
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, AbortOnTimeout) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   request_manager_->SetTimeoutForTests(base::TimeDelta::FromSeconds(0));
   const int request_id = request_manager_->CreateRequest(
-      RequestManager::TESTING,
+      TESTING,
       make_scoped_ptr<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
-  EXPECT_EQ(RequestManager::TESTING, observer.created()[0].type());
+  EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   // Wait until the request is timeouted.
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(1u, logger.error_events().size());
   EventLogger::ErrorEvent* event = logger.error_events()[0];
   EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error());
 
   ASSERT_EQ(1u, observer.rejected().size());
   EXPECT_EQ(request_id, observer.rejected()[0].request_id());
   EXPECT_EQ(base::File::FILE_ERROR_ABORT, observer.rejected()[0].error());
   ASSERT_EQ(1u, observer.timeouted().size());
   EXPECT_EQ(request_id, observer.timeouted()[0].request_id());
   ASSERT_EQ(1u, observer.destroyed().size());
   EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos