Resolve issues with WRITE_RESULT constants (net/)

When building using jumbo the WRITE_RESULT constants
defined in net/disk_cache/memory/mem_entry_impl.cc
and in net/disk_cache/simple/simple_entry_impl.cc
conflict with each other.

This commit solves the issue by renaming the constants to
something more file specific.

Bug: 772146
Change-Id: I118bea2e4943983975640ce178a48adb597f25f3
Reviewed-on: https://chromium-review.googlesource.com/1117066Reviewed-by: Josh Karlin <jkarlin@chromium.org>
Commit-Queue: Oscar Johansson <oscarj@opera.com>
Cr-Commit-Position: refs/heads/master@{#571042}

net/disk_cache/memory/mem_entry_impl.cc

@@ -35,16 +35,17 @@ const int kMaxSparseEntryBits = 12;
 const int kMaxSparseEntrySize = 1 << kMaxSparseEntryBits;
 
 // This enum is used for histograms, so only append to the end.
-enum WriteResult {
-  WRITE_RESULT_SUCCESS = 0,
-  WRITE_RESULT_INVALID_ARGUMENT = 1,
-  WRITE_RESULT_OVER_MAX_ENTRY_SIZE = 2,
-  WRITE_RESULT_EXCEEDED_CACHE_STORAGE_SIZE = 3,
-  WRITE_RESULT_MAX = 4,
+enum MemEntryWriteResult {
+  MEM_ENTRY_WRITE_RESULT_SUCCESS = 0,
+  MEM_ENTRY_WRITE_RESULT_INVALID_ARGUMENT = 1,
+  MEM_ENTRY_WRITE_RESULT_OVER_MAX_ENTRY_SIZE = 2,
+  MEM_ENTRY_WRITE_RESULT_EXCEEDED_CACHE_STORAGE_SIZE = 3,
+  MEM_ENTRY_WRITE_RESULT_MAX = 4,
 };
 
-void RecordWriteResult(WriteResult result) {
-  UMA_HISTOGRAM_ENUMERATION("MemCache.WriteResult", result, WRITE_RESULT_MAX);
+void RecordWriteResult(MemEntryWriteResult result) {
+  UMA_HISTOGRAM_ENUMERATION("MemCache.WriteResult", result,
+                            MEM_ENTRY_WRITE_RESULT_MAX);
 }
 
 // Convert global offset to child index.
@@ -367,17 +368,17 @@ int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
   if (!backend_) {
     // We have to fail writes after the backend is destroyed since we can't
     // ensure we wouldn't use too much memory if it's gone.
-    RecordWriteResult(WRITE_RESULT_EXCEEDED_CACHE_STORAGE_SIZE);
+    RecordWriteResult(MEM_ENTRY_WRITE_RESULT_EXCEEDED_CACHE_STORAGE_SIZE);
     return net::ERR_INSUFFICIENT_RESOURCES;
   }
 
   if (index < 0 || index >= kNumStreams) {
-    RecordWriteResult(WRITE_RESULT_INVALID_ARGUMENT);
+    RecordWriteResult(MEM_ENTRY_WRITE_RESULT_INVALID_ARGUMENT);
     return net::ERR_INVALID_ARGUMENT;
   }
 
   if (offset < 0 || buf_len < 0) {
-    RecordWriteResult(WRITE_RESULT_INVALID_ARGUMENT);
+    RecordWriteResult(MEM_ENTRY_WRITE_RESULT_INVALID_ARGUMENT);
     return net::ERR_INVALID_ARGUMENT;
   }
 
@@ -386,7 +387,7 @@ int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
   // offset of buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
-    RecordWriteResult(WRITE_RESULT_OVER_MAX_ENTRY_SIZE);
+    RecordWriteResult(MEM_ENTRY_WRITE_RESULT_OVER_MAX_ENTRY_SIZE);
     return net::ERR_FAILED;
   }
 
@@ -396,7 +397,7 @@ int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
     backend_->ModifyStorageSize(delta);
     if (backend_->HasExceededStorageSize()) {
       backend_->ModifyStorageSize(-delta);
-      RecordWriteResult(WRITE_RESULT_EXCEEDED_CACHE_STORAGE_SIZE);
+      RecordWriteResult(MEM_ENTRY_WRITE_RESULT_EXCEEDED_CACHE_STORAGE_SIZE);
       return net::ERR_INSUFFICIENT_RESOURCES;
     }
 
@@ -410,7 +411,7 @@ int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
   }
 
   UpdateStateOnUse(ENTRY_WAS_MODIFIED);
-  RecordWriteResult(WRITE_RESULT_SUCCESS);
+  RecordWriteResult(MEM_ENTRY_WRITE_RESULT_SUCCESS);
 
   if (!buf_len)
     return 0;

net/disk_cache/simple/simple_entry_impl.cc

@@ -45,14 +45,14 @@ namespace {
 const int64_t kMaxSparseDataSizeDivisor = 10;
 
 // Used in histograms, please only add entries at the end.
-enum WriteResult {
-  WRITE_RESULT_SUCCESS = 0,
-  WRITE_RESULT_INVALID_ARGUMENT = 1,
-  WRITE_RESULT_OVER_MAX_SIZE = 2,
-  WRITE_RESULT_BAD_STATE = 3,
-  WRITE_RESULT_SYNC_WRITE_FAILURE = 4,
-  WRITE_RESULT_FAST_EMPTY_RETURN = 5,
-  WRITE_RESULT_MAX = 6,
+enum SimpleEntryWriteResult {
+  SIMPLE_ENTRY_WRITE_RESULT_SUCCESS = 0,
+  SIMPLE_ENTRY_WRITE_RESULT_INVALID_ARGUMENT = 1,
+  SIMPLE_ENTRY_WRITE_RESULT_OVER_MAX_SIZE = 2,
+  SIMPLE_ENTRY_WRITE_RESULT_BAD_STATE = 3,
+  SIMPLE_ENTRY_WRITE_RESULT_SYNC_WRITE_FAILURE = 4,
+  SIMPLE_ENTRY_WRITE_RESULT_FAST_EMPTY_RETURN = 5,
+  SIMPLE_ENTRY_WRITE_RESULT_MAX = 6,
 };
 
 void RecordReadResult(net::CacheType cache_type, SimpleReadResult result) {
@@ -60,9 +60,10 @@ void RecordReadResult(net::CacheType cache_type, SimpleReadResult result) {
                    "ReadResult", cache_type, result, READ_RESULT_MAX);
 }
 
-void RecordWriteResult(net::CacheType cache_type, WriteResult result) {
-  SIMPLE_CACHE_UMA(ENUMERATION,
-                   "WriteResult2", cache_type, result, WRITE_RESULT_MAX);
+void RecordWriteResult(net::CacheType cache_type,
+                       SimpleEntryWriteResult result) {
+  SIMPLE_CACHE_UMA(ENUMERATION, "WriteResult2", cache_type, result,
+                   SIMPLE_ENTRY_WRITE_RESULT_MAX);
 }
 
 void RecordHeaderSize(net::CacheType cache_type, int size) {
@@ -428,7 +429,7 @@ int SimpleEntryImpl::WriteData(int stream_index,
           net::NetLogEventType::SIMPLE_CACHE_ENTRY_WRITE_END,
           CreateNetLogReadWriteCompleteCallback(net::ERR_INVALID_ARGUMENT));
     }
-    RecordWriteResult(cache_type_, WRITE_RESULT_INVALID_ARGUMENT);
+    RecordWriteResult(cache_type_, SIMPLE_ENTRY_WRITE_RESULT_INVALID_ARGUMENT);
     return net::ERR_INVALID_ARGUMENT;
   }
   if (backend_.get() && offset + buf_len > backend_->GetMaxFileSize()) {
@@ -436,7 +437,7 @@ int SimpleEntryImpl::WriteData(int stream_index,
       net_log_.AddEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY_WRITE_END,
                         CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
     }
-    RecordWriteResult(cache_type_, WRITE_RESULT_OVER_MAX_SIZE);
+    RecordWriteResult(cache_type_, SIMPLE_ENTRY_WRITE_RESULT_OVER_MAX_SIZE);
     return net::ERR_FAILED;
   }
   ScopedOperationRunner operation_runner(this);
@@ -949,7 +950,7 @@ void SimpleEntryImpl::WriteDataInternal(int stream_index,
   }
 
   if (state_ == STATE_FAILURE || state_ == STATE_UNINITIALIZED) {
-    RecordWriteResult(cache_type_, WRITE_RESULT_BAD_STATE);
+    RecordWriteResult(cache_type_, SIMPLE_ENTRY_WRITE_RESULT_BAD_STATE);
     if (net_log_.IsCapturing()) {
       net_log_.AddEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY_WRITE_END,
                         CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
@@ -978,7 +979,8 @@ void SimpleEntryImpl::WriteDataInternal(int stream_index,
   if (buf_len == 0) {
     int32_t data_size = data_size_[stream_index];
     if (truncate ? (offset == data_size) : (offset <= data_size)) {
-      RecordWriteResult(cache_type_, WRITE_RESULT_FAST_EMPTY_RETURN);
+      RecordWriteResult(cache_type_,
+                        SIMPLE_ENTRY_WRITE_RESULT_FAST_EMPTY_RETURN);
       if (!callback.is_null()) {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::BindOnce(std::move(callback), 0));
@@ -1400,9 +1402,10 @@ void SimpleEntryImpl::WriteOperationComplete(
     net::IOBuffer* buf) {
   int result = write_result->result;
   if (result >= 0)
-    RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
+    RecordWriteResult(cache_type_, SIMPLE_ENTRY_WRITE_RESULT_SUCCESS);
   else
-    RecordWriteResult(cache_type_, WRITE_RESULT_SYNC_WRITE_FAILURE);
+    RecordWriteResult(cache_type_,
+                      SIMPLE_ENTRY_WRITE_RESULT_SYNC_WRITE_FAILURE);
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY_WRITE_END,
                       CreateNetLogReadWriteCompleteCallback(result));
@@ -1657,7 +1660,7 @@ int SimpleEntryImpl::SetStream0Data(net::IOBuffer* buf,
   UpdateDataFromEntryStat(
       SimpleEntryStat(modification_time, modification_time, data_size_,
                       sparse_data_size_));
-  RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
+  RecordWriteResult(cache_type_, SIMPLE_ENTRY_WRITE_RESULT_SUCCESS);
   return buf_len;
 }