[usb-request] Remove req_size from Alloc.

Tested: runtests -t usb-unittest
Change-Id: If51ad062fbaf5157749635c40e587bc37f962ad7
diff --git a/system/dev/lib/usb/include/usb/request-cpp.h b/system/dev/lib/usb/include/usb/request-cpp.h
index 34f29ae..6121363 100644
--- a/system/dev/lib/usb/include/usb/request-cpp.h
+++ b/system/dev/lib/usb/include/usb/request-cpp.h
@@ -69,7 +69,7 @@
 // const size_t op_size = usb::Request<>::RequestSize(parent_req_size);
 // for (int i = 0; i < kNumRequest; i++) {
 //     std::optional<usb::Request> request;
-//     request = usb::Request::Alloc(op_size, parent_req_size);
+//     request = usb::Request::Alloc(op_size, DATA_SIZE, EP_ADDRESS, parent_req_size);
 //
 //     if (!request) return ZX_ERR_NO_MEMORY;
 //     pool.add(std::move(*request));
@@ -200,8 +200,8 @@
 
     // Creates a new usb request with payload space of data_size.
     static zx_status_t Alloc(std::optional<Request>* out, uint64_t data_size,
-                             uint8_t ep_address, size_t req_size,
-                             size_t parent_req_size = sizeof(usb_request_t)) {
+                             uint8_t ep_address, size_t parent_req_size) {
+        const size_t req_size = RequestSize(parent_req_size);
         usb_request_t* request;
         zx_status_t status = usb_request_alloc(&request, data_size, ep_address, req_size);
         if (status == ZX_OK) {
@@ -216,7 +216,8 @@
     // Creates a new usb request with the given VMO.
     static zx_status_t AllocVmo(std::optional<Request>* out, const zx::vmo& vmo,
                                 uint64_t vmo_offset, uint64_t length, uint8_t ep_address,
-                                size_t req_size, size_t parent_req_size = sizeof(usb_request_t)) {
+                                size_t parent_req_size) {
+        const size_t req_size = RequestSize(parent_req_size);
         usb_request_t* request;
         zx_status_t status = usb_request_alloc_vmo(&request, vmo.get(), vmo_offset, length,
                                                    ep_address, req_size);
diff --git a/system/dev/test/usb/usb-request-pool-test.cpp b/system/dev/test/usb/usb-request-pool-test.cpp
index 3df395f..d8afac0 100644
--- a/system/dev/test/usb/usb-request-pool-test.cpp
+++ b/system/dev/test/usb/usb-request-pool-test.cpp
@@ -22,7 +22,7 @@
 bool SingleRequestTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize),
+    ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize),
               ZX_OK);
 
     usb::RequestPool pool;
@@ -40,7 +40,7 @@
 
     for (size_t i = 0; i < 10; i++) {
         std::optional<Request> request;
-        ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize),
+        ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize),
                   ZX_OK);
         pool.Add(std::move(*request));
     }
@@ -59,8 +59,7 @@
     for (size_t i = 0; i < 10; i++) {
         const size_t size = kParentReqSize + i * 8;
         std::optional<Request> request;
-        ASSERT_EQ(Request::Alloc(&request, 0, 0,
-                                 Request::RequestSize(size)),
+        ASSERT_EQ(Request::Alloc(&request, 0, 0, size),
                   ZX_OK);
         pool.Add(std::move(*request));
     }
@@ -79,7 +78,7 @@
 
     for (size_t i = 0; i < 10; i++) {
         std::optional<Request> request;
-        ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize),
+        ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize),
                   ZX_OK);
         pool.Add(std::move(*request));
     }
diff --git a/system/dev/test/usb/usb-request-queue-test.cpp b/system/dev/test/usb/usb-request-queue-test.cpp
index f058a4f..102c75f 100644
--- a/system/dev/test/usb/usb-request-queue-test.cpp
+++ b/system/dev/test/usb/usb-request-queue-test.cpp
@@ -11,7 +11,6 @@
 using Request = usb::Request<void>;
 
 constexpr size_t kParentReqSize = sizeof(usb_request_t);
-constexpr size_t kReqSize = Request::RequestSize(kParentReqSize);
 constexpr usb_request_complete_t kNoCallback = {};
 
 bool TrivialLifetimeTest() {
@@ -24,7 +23,7 @@
 bool SingleRequestTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize),
+    ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize),
               ZX_OK);
 
     usb::RequestQueue<void> queue;
@@ -41,7 +40,7 @@
 
     for (size_t i = 0; i < 10; i++) {
         std::optional<Request> request;
-        ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize),
+        ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize),
                   ZX_OK);
         queue.push(std::move(*request));
     }
@@ -60,7 +59,7 @@
 
     for (size_t i = 0; i < 10; i++) {
         std::optional<Request> request;
-        ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize),
+        ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize),
                   ZX_OK);
         queue1.push(std::move(*request));
     }
@@ -81,7 +80,7 @@
 
     for (size_t i = 0; i < 10; i++) {
         std::optional<Request> request;
-        ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize),
+        ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize),
                   ZX_OK);
         queue.push(std::move(*request));
     }
@@ -99,12 +98,11 @@
 
     constexpr size_t kBaseReqSize = sizeof(usb_request_t);
     constexpr size_t kFirstLayerReqSize = FirstLayerReq::RequestSize(kBaseReqSize);
-    constexpr size_t kSecondLayerReqSize = SecondLayerReq::RequestSize(kFirstLayerReqSize);
 
     usb::RequestQueue<void> queue;
     for (size_t i = 0; i < 10; i++) {
         std::optional<SecondLayerReq> request;
-        ASSERT_EQ(SecondLayerReq::Alloc(&request, 0, 0, kSecondLayerReqSize, kFirstLayerReqSize),
+        ASSERT_EQ(SecondLayerReq::Alloc(&request, 0, 0, kFirstLayerReqSize),
                   ZX_OK);
         queue.push(std::move(*request));
     }
@@ -137,12 +135,11 @@
 
     constexpr size_t kBaseReqSize = sizeof(usb_request_t);
     constexpr size_t kFirstLayerReqSize = FirstLayerReq::RequestSize(kBaseReqSize);
-    constexpr size_t kSecondLayerReqSize = SecondLayerReq::RequestSize(kFirstLayerReqSize);
 
     usb::RequestQueue<uint64_t> queue;
     for (size_t i = 0; i < 10; i++) {
         std::optional<SecondLayerReq> request;
-        ASSERT_EQ(SecondLayerReq::Alloc(&request, 0, 0, kSecondLayerReqSize, kFirstLayerReqSize),
+        ASSERT_EQ(SecondLayerReq::Alloc(&request, 0, 0, kFirstLayerReqSize),
                   ZX_OK);
         *request->private_storage() = i;
         EXPECT_EQ(*request->private_storage(), i);
@@ -180,12 +177,11 @@
 
     constexpr size_t kBaseReqSize = sizeof(usb_request_t);
     constexpr size_t kFirstLayerReqSize = FirstLayerReq::RequestSize(kBaseReqSize);
-    constexpr size_t kSecondLayerReqSize = SecondLayerReq::RequestSize(kFirstLayerReqSize);
 
     usb::RequestQueue<uint64_t> queue;
     for (size_t i = 0; i < 10; i++) {
         std::optional<SecondLayerReq> request;
-        ASSERT_EQ(SecondLayerReq::Alloc(&request, 0, 0, kSecondLayerReqSize, kFirstLayerReqSize),
+        ASSERT_EQ(SecondLayerReq::Alloc(&request, 0, 0, kFirstLayerReqSize),
                   ZX_OK);
         *request->private_storage() = i;
         EXPECT_EQ(*request->private_storage(), i);
diff --git a/system/dev/test/usb/usb-request-test.cpp b/system/dev/test/usb/usb-request-test.cpp
index 0acaa89..8e10fdf 100644
--- a/system/dev/test/usb/usb-request-test.cpp
+++ b/system/dev/test/usb/usb-request-test.cpp
@@ -16,13 +16,12 @@
 using Request = usb::Request<void>;
 
 constexpr size_t kParentReqSize = sizeof(usb_request_t);
-constexpr size_t kReqSize = Request::RequestSize(kParentReqSize);
 constexpr usb_request_complete_t kNoCallback = {};
 
 bool AllocTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    EXPECT_EQ(Request::Alloc(&request, 0, 0, kReqSize), ZX_OK);
+    EXPECT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize), ZX_OK);
     END_TEST;
 }
 
@@ -31,7 +30,7 @@
     zx::vmo vmo;
     ASSERT_EQ(zx::vmo::create(ZX_PAGE_SIZE, 0, &vmo), ZX_OK);
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, 0, 0, kReqSize), ZX_OK);
+    ASSERT_EQ(Request::Alloc(&request, 0, 0, kParentReqSize), ZX_OK);
     EXPECT_EQ(request->Init(vmo, 0, 0, 0),
               ZX_OK);
     END_TEST;
@@ -42,7 +41,7 @@
     zx::vmo vmo;
     ASSERT_EQ(zx::vmo::create(ZX_PAGE_SIZE, 0, &vmo), ZX_OK);
     std::optional<Request> request;
-    EXPECT_EQ(Request::AllocVmo(&request, vmo, 0, 0, 0, kReqSize),
+    EXPECT_EQ(Request::AllocVmo(&request, vmo, 0, 0, 0, kParentReqSize),
               ZX_OK);
     END_TEST;
 }
@@ -50,7 +49,7 @@
 bool CopyTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kReqSize),
+    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kParentReqSize),
               ZX_OK);
 
     constexpr uint8_t kSampleData[] = "blahblahblah";
@@ -66,7 +65,7 @@
 bool MmapTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kReqSize),
+    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kParentReqSize),
               ZX_OK);
 
     constexpr uint8_t kSampleData[] = "blahblahblah";
@@ -82,7 +81,7 @@
 bool CacheOpTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kReqSize),
+    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kParentReqSize),
               ZX_OK);
 
     EXPECT_EQ(request->CacheOp(USB_REQUEST_CACHE_INVALIDATE, 0, 0), ZX_OK);
@@ -99,7 +98,7 @@
 bool CacheFlushTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kReqSize),
+    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kParentReqSize),
               ZX_OK);
 
     EXPECT_EQ(request->CacheFlush(0, 0), ZX_OK);
@@ -112,7 +111,7 @@
 bool CacheFlushInvalidateTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kReqSize),
+    EXPECT_EQ(Request::Alloc(&request, ZX_PAGE_SIZE, 0, kParentReqSize),
               ZX_OK);
 
     EXPECT_EQ(request->CacheFlushInvalidate(0, 0), ZX_OK);
@@ -130,7 +129,7 @@
     zx::unowned_bti bti(bti_handle);
 
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 4, 1, kReqSize),
+    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 4, 1, kParentReqSize),
               ZX_OK);
 
     ASSERT_EQ(request->PhysMap(*bti), ZX_OK);
@@ -146,7 +145,7 @@
     zx::unowned_bti bti(bti_handle);
 
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 4, 1, kReqSize),
+    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 4, 1, kParentReqSize),
               ZX_OK);
 
     ASSERT_EQ(request->PhysMap(*bti), ZX_OK);
@@ -169,7 +168,7 @@
 bool SetScatterGatherListTest() {
     BEGIN_TEST;
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 3, 1, kReqSize),
+    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 3, 1, kParentReqSize),
               ZX_OK);
     // Wrap around the end of the request.
     constexpr phys_iter_sg_entry_t kWrapped[] = {
@@ -194,7 +193,7 @@
     zx::vmo vmo;
     ASSERT_EQ(zx::vmo::create(ZX_PAGE_SIZE * 3, 0, &vmo), ZX_OK);
     std::optional<Request> request;
-    ASSERT_EQ(Request::AllocVmo(&request, vmo, PAGE_SIZE, PAGE_SIZE * 3, 0, kReqSize),
+    ASSERT_EQ(Request::AllocVmo(&request, vmo, PAGE_SIZE, PAGE_SIZE * 3, 0, kParentReqSize),
               ZX_OK);
 
     constexpr phys_iter_sg_entry_t kOutOfBounds[] = {
@@ -219,7 +218,7 @@
     zx::unowned_bti bti(bti_handle);
 
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 4, 1, kReqSize),
+    ASSERT_EQ(Request::Alloc(&request, PAGE_SIZE * 4, 1, kParentReqSize),
               ZX_OK);
 
     ASSERT_EQ(request->PhysMap(*bti), ZX_OK);
@@ -276,15 +275,13 @@
     constexpr size_t kFirstLayerReqSize = Request::RequestSize(kBaseReqSize);
     constexpr size_t kSecondLayerReqSize =
         usb::UnownedRequest<void>::RequestSize(kFirstLayerReqSize);
-    constexpr size_t kThirdLayerReqSize =
-        usb::UnownedRequest<void>::RequestSize(kSecondLayerReqSize);
 
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, 0, 0, kThirdLayerReqSize), ZX_OK);
+    ASSERT_EQ(Request::Alloc(&request, 0, 0, kSecondLayerReqSize), ZX_OK);
 
     usb::UnownedRequest request2(request->take(), kNoCallback, kFirstLayerReqSize);
-    usb::UnownedRequest request3(request2.take(), kNoCallback, kSecondLayerReqSize);
-    request = usb::Request(request3.take(), kBaseReqSize);
+    usb::UnownedRequest request3(request2.take(), kNoCallback, kBaseReqSize);
+    request = usb::Request(request3.take(), kSecondLayerReqSize);
 
     END_TEST;
 }
@@ -303,8 +300,6 @@
     BEGIN_TEST;
     constexpr size_t kBaseReqSize = sizeof(usb_request_t);
     constexpr size_t kFirstLayerReqSize = Request::RequestSize(kBaseReqSize);
-    constexpr size_t kSecondLayerReqSize =
-        usb::UnownedRequest<void>::RequestSize(kFirstLayerReqSize);
 
     bool called = false;
     auto callback = [](void* ctx, usb_request_t* request) {
@@ -318,9 +313,9 @@
     };
 
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, 0, 0, kSecondLayerReqSize), ZX_OK);
+    ASSERT_EQ(Request::Alloc(&request, 0, 0, kFirstLayerReqSize), ZX_OK);
 
-    usb::UnownedRequest<void> request2(request->take(), complete_cb, kFirstLayerReqSize);
+    usb::UnownedRequest<void> request2(request->take(), complete_cb, kBaseReqSize);
     request2.Complete(ZX_OK, 0);
     EXPECT_TRUE(called);
 
@@ -331,14 +326,12 @@
     BEGIN_TEST;
     constexpr size_t kBaseReqSize = sizeof(usb_request_t);
     constexpr size_t kFirstLayerReqSize = Request::RequestSize(kBaseReqSize);
-    constexpr size_t kSecondLayerReqSize =
-        usb::UnownedRequest<void>::RequestSize(kFirstLayerReqSize);
 
     bool called = false;
     auto callback = [](void* ctx, usb_request_t* request) {
         *static_cast<bool*>(ctx) = true;
         // We take ownership.
-        Request unused(request, kBaseReqSize);
+        Request unused(request, kFirstLayerReqSize);
     };
     usb_request_complete_t complete_cb = {
         .callback = callback,
@@ -346,10 +339,10 @@
     };
 
     std::optional<Request> request;
-    ASSERT_EQ(Request::Alloc(&request, 0, 0, kSecondLayerReqSize), ZX_OK);
+    ASSERT_EQ(Request::Alloc(&request, 0, 0, kFirstLayerReqSize), ZX_OK);
 
     {
-        usb::UnownedRequest<void> request2(request->take(), complete_cb, kFirstLayerReqSize);
+        usb::UnownedRequest<void> request2(request->take(), complete_cb, kBaseReqSize);
     }
     EXPECT_TRUE(called);