LogDog: Add log rendering view.

common/logdog/fetcher/fetcher.go

 // Copyright 2015 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.
 
 package fetcher
 
 import (
         "fmt"
         "io"
         "time"
@@ skipping 13 matching lines @@
         // DefaultBufferBytes is the default number of bytes to buffer.
         DefaultBufferBytes = int64(1024 * 1024) // 1MB
 )
 
 // LogRequest is a structure used by the Fetcher to request a range of logs
 // from its Source.
 type LogRequest struct {
         // Index is the starting log index to request.
         Index types.MessageIndex
         // Count, if >0, is the maximum number of log entries to request.
-        Count int
+        Count int64
         // Bytes, if >0, is the maximum number of log bytes to request. At least one
         // log must be returned regardless of the byte limit.
         Bytes int64
 }
 
 // Source is the source of log stream and log information.
 //
 // The Source is resposible for handling retries, backoff, and transient errors.
 // An error from the Source will shut down the Fetcher.
 type Source interface {
@@ skipping 108 matching lines @@
                 }
                 if resp.log != nil {
                         le = resp.log
                 }
         }
         return le, f.fetchErr
 }
 
 type fetchRequest struct {
         index types.MessageIndex
-        count int
+        count int64
         bytes int64
         respC chan *fetchResponse
 }
 
 type fetchResponse struct {
         logs []*logpb.LogEntry
         tidx types.MessageIndex
         err  error
 }
 
@@ skipping 71 matching lines @@
                                 case fetchCount == 0, remaining < fetchCount:
                                         fetchCount = remaining
                                 }
                         }
 
                         // Fetch logs if neither constraint has vetoed.
                         if fetchCount >= 0 && fetchBytes >= 0 {
                                 logFetchC = logFetchBaseC
                                 req := fetchRequest{
                                         index: nextFetchIndex,
-                                        count: int(fetchCount),
+                                        count: fetchCount,
                                         bytes: fetchBytes,
                                         respC: logFetchC,
                                 }
 
                                 log.Fields{
                                         "index": req.index,
                                         "count": req.count,
                                         "bytes": req.bytes,
                                 }.Debugf(c, "Buffering next round of logs...")
                                 go f.fetchLogs(c, &req)
@@ skipping 118 matching lines @@
         case want > have:
                 // We have fewer logs buffered. Fetch the difference (including
                 // prefetch).
                 return (want * int64(f.o.PrefetchFactor)) - have
 
         default:
                 // We're within our constraint. Do not fetch logs.
                 return -1
         }
 }