LogDog: Add log rendering view.

server/logdog/storage/memory/memory.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 memory
 
 import (
         "errors"
         "sync"
 
@@ skipping 11 matching lines @@
         data  []byte
 }
 
 // Storage is an implementation of the storage.Storage interface that stores
 // data in memory.
 //
 // This is intended for testing, and not intended to be performant.
 type Storage struct {
         // MaxGetCount, if not zero, is the maximum number of records to retrieve from
         // a single Get request.
-        MaxGetCount int
+        MaxGetCount int64
 
         stateMu sync.Mutex
         streams map[types.StreamPath]*logStream
         closed  bool
 }
 
 var _ storage.Storage = (*Storage)(nil)
 
 // Close implements storage.Storage.
 func (s *Storage) Close() {
@@ skipping 22 matching lines @@
 
 // Get implements storage.Storage.
 func (s *Storage) Get(req *storage.GetRequest, cb storage.GetCallback) error {
         recs := []*rec(nil)
         err := s.run(func() error {
                 ls := s.getLogStreamLocked(req.Path, false)
                 if ls == nil {
                         return storage.ErrDoesNotExist
                 }
 
-                limit := len(ls.logs)
+                limit := int64(len(ls.logs))
                 if req.Limit > 0 && req.Limit < limit {
                         limit = req.Limit
                 }
                 if s.MaxGetCount > 0 && s.MaxGetCount < limit {
                         limit = s.MaxGetCount
                 }
 
                 // Grab all records starting from our start index.
                 for idx := req.Index; idx <= ls.latestIndex; idx++ {
                         if le, ok := ls.logs[idx]; ok {
                                 recs = append(recs, &rec{
                                         index: idx,
                                         data:  le,
                                 })
                         }
 
-                        if len(recs) >= limit {
+                        if int64(len(recs)) >= limit {
                                 break
                         }
                 }
                 return nil
         })
         if err != nil {
                 return err
         }
 
         // Punt all of the records upstream. We copy the data to prevent the
@@ skipping 75 matching lines @@
                 }
 
                 if s.streams == nil {
                         s.streams = map[types.StreamPath]*logStream{}
                 }
                 s.streams[p] = ls
         }
 
         return ls
 }