Try to consistently use arraysize() with strlcpy().

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2006-2008 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 "base/basictypes.h"
 #include "base/platform_thread.h"
 #include "base/timer.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
@@ skipping 20 matching lines @@
 };
 
 void DiskCacheEntryTest::InternalSyncIO() {
   disk_cache::Entry *entry1 = NULL;
   ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
 
   char buffer1[10];
   CacheTestFillBuffer(buffer1, sizeof(buffer1), false);
   EXPECT_EQ(0, entry1->ReadData(0, 0, buffer1, sizeof(buffer1), NULL));
-  base::strlcpy(buffer1, "the data", sizeof(buffer1));
+  base::strlcpy(buffer1, "the data", arraysize(buffer1));
   EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, sizeof(buffer1), NULL, false));
   memset(buffer1, 0, sizeof(buffer1));
   EXPECT_EQ(10, entry1->ReadData(0, 0, buffer1, sizeof(buffer1), NULL));
   EXPECT_STREQ("the data", buffer1);
 
   char buffer2[5000];
   char buffer3[10000] = {0};
   CacheTestFillBuffer(buffer2, sizeof(buffer2), false);
-  base::strlcpy(buffer2, "The really big data goes here", sizeof(buffer2));
+  base::strlcpy(buffer2, "The really big data goes here", arraysize(buffer2));
   EXPECT_EQ(5000, entry1->WriteData(1, 1500, buffer2, sizeof(buffer2), NULL,
                                     false));
   memset(buffer2, 0, sizeof(buffer2));
   EXPECT_EQ(4989, entry1->ReadData(1, 1511, buffer2, sizeof(buffer2), NULL));
   EXPECT_STREQ("big data goes here", buffer2);
   EXPECT_EQ(5000, entry1->ReadData(1, 0, buffer2, sizeof(buffer2), NULL));
   EXPECT_EQ(0, memcmp(buffer2, buffer3, 1500));
   EXPECT_EQ(1500, entry1->ReadData(1, 5000, buffer2, sizeof(buffer2), NULL));
 
   EXPECT_EQ(0, entry1->ReadData(1, 6500, buffer2, sizeof(buffer2), NULL));
@@ skipping 45 matching lines @@
   MessageLoopHelper helper;
 
   char buffer1[10];
   char buffer2[5000];
   char buffer3[10000];
   CacheTestFillBuffer(buffer1, sizeof(buffer1), false);
   CacheTestFillBuffer(buffer2, sizeof(buffer2), false);
   CacheTestFillBuffer(buffer3, sizeof(buffer3), false);
 
   EXPECT_EQ(0, entry1->ReadData(0, 0, buffer1, sizeof(buffer1), &callback1));
-  base::strlcpy(buffer1, "the data", sizeof(buffer1));
+  base::strlcpy(buffer1, "the data", arraysize(buffer1));
   int expected = 0;
   int ret = entry1->WriteData(0, 0, buffer1, sizeof(buffer1), &callback2,
                               false);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   memset(buffer2, 0, sizeof(buffer1));
   ret = entry1->ReadData(0, 0, buffer2, sizeof(buffer1), &callback3);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   g_cache_tests_max_id = 3;
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("the data", buffer2);
 
-  base::strlcpy(buffer2, "The really big data goes here", sizeof(buffer2));
+  base::strlcpy(buffer2, "The really big data goes here", arraysize(buffer2));
   ret = entry1->WriteData(1, 1500, buffer2, sizeof(buffer2), &callback4, false);
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   memset(buffer3, 0, sizeof(buffer2));
   ret = entry1->ReadData(1, 1511, buffer3, sizeof(buffer2), &callback5);
   EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
@@ skipping 66 matching lines @@
   InternalAsyncIO();
 }
 
 void DiskCacheEntryTest::ExternalSyncIO() {
   disk_cache::Entry *entry1;
   ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1));
 
   char buffer1[17000], buffer2[25000];
   CacheTestFillBuffer(buffer1, sizeof(buffer1), false);
   CacheTestFillBuffer(buffer2, sizeof(buffer2), false);
-  base::strlcpy(buffer1, "the data", sizeof(buffer1));
+  base::strlcpy(buffer1, "the data", arraysize(buffer1));
   EXPECT_EQ(17000, entry1->WriteData(0, 0, buffer1, sizeof(buffer1), NULL,
                                      false));
   memset(buffer1, 0, sizeof(buffer1));
   EXPECT_EQ(17000, entry1->ReadData(0, 0, buffer1, sizeof(buffer1), NULL));
   EXPECT_STREQ("the data", buffer1);
 
-  base::strlcpy(buffer2, "The really big data goes here", sizeof(buffer2));
+  base::strlcpy(buffer2, "The really big data goes here", arraysize(buffer2));
   EXPECT_EQ(25000, entry1->WriteData(1, 10000, buffer2, sizeof(buffer2), NULL,
                                      false));
   memset(buffer2, 0, sizeof(buffer2));
   EXPECT_EQ(24989, entry1->ReadData(1, 10011, buffer2, sizeof(buffer2), NULL));
   EXPECT_STREQ("big data goes here", buffer2);
   EXPECT_EQ(25000, entry1->ReadData(1, 0, buffer2, sizeof(buffer2), NULL));
   EXPECT_EQ(0, memcmp(buffer2, buffer2, 10000));
   EXPECT_EQ(5000, entry1->ReadData(1, 30000, buffer2, sizeof(buffer2), NULL));
 
   EXPECT_EQ(0, entry1->ReadData(1, 35000, buffer2, sizeof(buffer2), NULL));
@@ skipping 37 matching lines @@
   g_cache_tests_max_id = 0;
   g_cache_tests_received = 0;
   int expected = 0;
 
   MessageLoopHelper helper;
 
   char buffer1[17000], buffer2[25000], buffer3[25000];
   CacheTestFillBuffer(buffer1, sizeof(buffer1), false);
   CacheTestFillBuffer(buffer2, sizeof(buffer2), false);
   CacheTestFillBuffer(buffer3, sizeof(buffer3), false);
-  base::strlcpy(buffer1, "the data", sizeof(buffer1));
+  base::strlcpy(buffer1, "the data", arraysize(buffer1));
   int ret = entry1->WriteData(0, 0, buffer1, sizeof(buffer1), &callback1,
                               false);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   g_cache_tests_max_id = 1;
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
 
   memset(buffer2, 0, sizeof(buffer1));
   ret = entry1->ReadData(0, 0, buffer2, sizeof(buffer1), &callback2);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   g_cache_tests_max_id = 2;
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("the data", buffer1);
 
-  base::strlcpy(buffer2, "The really big data goes here", sizeof(buffer2));
+  base::strlcpy(buffer2, "The really big data goes here", arraysize(buffer2));
   ret = entry1->WriteData(1, 10000, buffer2, sizeof(buffer2), &callback3,
                           false);
   EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   g_cache_tests_max_id = 3;
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
 
   memset(buffer3, 0, sizeof(buffer3));
@@ skipping 137 matching lines @@
 void DiskCacheEntryTest::GrowData() {
   std::string key1("the first key");
   disk_cache::Entry *entry1, *entry2;
   ASSERT_TRUE(cache_->CreateEntry(key1, &entry1));
 
   char buffer1[20000];
   char buffer2[20000];
   CacheTestFillBuffer(buffer1, sizeof(buffer1), false);
   memset(buffer2, 0, sizeof(buffer2));
 
-  base::strlcpy(buffer1, "the data", sizeof(buffer1));
+  base::strlcpy(buffer1, "the data", arraysize(buffer1));
   EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, 10, NULL, false));
   EXPECT_EQ(10, entry1->ReadData(0, 0, buffer2, 10, NULL));
   EXPECT_STREQ("the data", buffer2);
   EXPECT_EQ(10, entry1->GetDataSize(0));
 
   EXPECT_EQ(2000, entry1->WriteData(0, 0, buffer1, 2000, NULL, false));
   EXPECT_EQ(2000, entry1->GetDataSize(0));
   EXPECT_EQ(2000, entry1->ReadData(0, 0, buffer2, 2000, NULL));
   EXPECT_TRUE(!memcmp(buffer1, buffer2, 2000));
 
@@ skipping 303 matching lines @@
   InitCache();
   DoomEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomEntry();
 }