Home | History | Annotate | Download | only in disk_cache 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/disk_cache/net_log_parameters.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "base/strings/string_number_conversions.h"
     10 #include "base/values.h"
     11 #include "net/base/net_errors.h"
     12 #include "net/disk_cache/disk_cache.h"
     13 
     14 namespace {
     15 
     16 base::Value* NetLogEntryCreationCallback(
     17     const disk_cache::Entry* entry,
     18     bool created,
     19     net::NetLog::LogLevel /* log_level */) {
     20   base::DictionaryValue* dict = new base::DictionaryValue();
     21   dict->SetString("key", entry->GetKey());
     22   dict->SetBoolean("created", created);
     23   return dict;
     24 }
     25 
     26 base::Value* NetLogReadWriteDataCallback(
     27     int index,
     28     int offset,
     29     int buf_len,
     30     bool truncate,
     31     net::NetLog::LogLevel /* log_level */) {
     32   base::DictionaryValue* dict = new base::DictionaryValue();
     33   dict->SetInteger("index", index);
     34   dict->SetInteger("offset", offset);
     35   dict->SetInteger("buf_len", buf_len);
     36   if (truncate)
     37     dict->SetBoolean("truncate", truncate);
     38   return dict;
     39 }
     40 
     41 base::Value* NetLogReadWriteCompleteCallback(
     42     int bytes_copied,
     43     net::NetLog::LogLevel /* log_level */) {
     44   DCHECK_NE(bytes_copied, net::ERR_IO_PENDING);
     45   base::DictionaryValue* dict = new base::DictionaryValue();
     46   if (bytes_copied < 0) {
     47     dict->SetInteger("net_error", bytes_copied);
     48   } else {
     49     dict->SetInteger("bytes_copied", bytes_copied);
     50   }
     51   return dict;
     52 }
     53 
     54 base::Value* NetLogSparseOperationCallback(
     55     int64 offset,
     56     int buff_len,
     57     net::NetLog::LogLevel /* log_level */) {
     58   base::DictionaryValue* dict = new base::DictionaryValue();
     59   // Values can only be created with at most 32-bit integers.  Using a string
     60   // instead circumvents that restriction.
     61   dict->SetString("offset", base::Int64ToString(offset));
     62   dict->SetInteger("buff_len", buff_len);
     63   return dict;
     64 }
     65 
     66 base::Value* NetLogSparseReadWriteCallback(
     67     const net::NetLog::Source& source,
     68     int child_len,
     69     net::NetLog::LogLevel /* log_level */) {
     70   base::DictionaryValue* dict = new base::DictionaryValue();
     71   source.AddToEventParameters(dict);
     72   dict->SetInteger("child_len", child_len);
     73   return dict;
     74 }
     75 
     76 base::Value* NetLogGetAvailableRangeResultCallback(
     77     int64 start,
     78     int result,
     79     net::NetLog::LogLevel /* log_level */) {
     80   base::DictionaryValue* dict = new base::DictionaryValue();
     81   if (result > 0) {
     82     dict->SetInteger("length", result);
     83     dict->SetString("start",  base::Int64ToString(start));
     84   } else {
     85     dict->SetInteger("net_error", result);
     86   }
     87   return dict;
     88 }
     89 
     90 }  // namespace
     91 
     92 namespace disk_cache {
     93 
     94 net::NetLog::ParametersCallback CreateNetLogEntryCreationCallback(
     95     const Entry* entry,
     96     bool created) {
     97   DCHECK(entry);
     98   return base::Bind(&NetLogEntryCreationCallback, entry, created);
     99 }
    100 
    101 net::NetLog::ParametersCallback CreateNetLogReadWriteDataCallback(
    102     int index,
    103     int offset,
    104     int buf_len,
    105     bool truncate) {
    106   return base::Bind(&NetLogReadWriteDataCallback,
    107                     index, offset, buf_len, truncate);
    108 }
    109 
    110 net::NetLog::ParametersCallback CreateNetLogReadWriteCompleteCallback(
    111     int bytes_copied) {
    112   return base::Bind(&NetLogReadWriteCompleteCallback, bytes_copied);
    113 }
    114 
    115 net::NetLog::ParametersCallback CreateNetLogSparseOperationCallback(
    116     int64 offset,
    117     int buff_len) {
    118   return base::Bind(&NetLogSparseOperationCallback, offset, buff_len);
    119 }
    120 
    121 net::NetLog::ParametersCallback CreateNetLogSparseReadWriteCallback(
    122     const net::NetLog::Source& source,
    123     int child_len) {
    124   return base::Bind(&NetLogSparseReadWriteCallback, source, child_len);
    125 }
    126 
    127 net::NetLog::ParametersCallback CreateNetLogGetAvailableRangeResultCallback(
    128     int64 start,
    129     int result) {
    130   return base::Bind(&NetLogGetAvailableRangeResultCallback, start, result);
    131 }
    132 
    133 }  // namespace disk_cache
    134