DnsQuery: changed raw function pointer to callback.

base/rand_util.h

 // Copyright (c) 2011 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.
 
 #ifndef BASE_RAND_UTIL_H_
 #define BASE_RAND_UTIL_H_
 #pragma once
 
 #include <string>
 
 #include "base/base_api.h"
 #include "base/basictypes.h"
+#include "base/callback.h"
 
 namespace base {
 
 // Returns a random number in range [0, kuint64max]. Thread-safe.
 BASE_API uint64 RandUint64();
 
 // Returns a random number between min and max (inclusive). Thread-safe.
 BASE_API int RandInt(int min, int max);
 
+typedef base::Callback<int(int, int)> RandIntCallback;

[brettw, 2011/06/27 22:24:48]

I don't understand why this is here. It's not necessary for any part of this
file, and introduces new header file dependencies. If you want a typedef, I'd
make it inside your Dns class.

[agayev, 2011/06/27 23:53:52]

I thought callback for a RandInt is general enough to belong here.  Its client
is not just Dns class.  Should I redefine it every time I need it?

[willchan no longer on Chromium, 2011/06/28 09:58:23]

This looks to be an ease of use vs dependency bloat tradeoff. It's not clear to
me, since callback.h will probably already be included in most places. But we've
recently been fighting to trim our dependencies, so I think I'd err on the side
of burdening the clients with having to define it themselves.

[brettw, 2011/06/28 16:09:52]

I might define it at the top of your DNS class so users can refer to it as
DNSQuery::RandomCallback if they need it.

[agayev, 2011/06/28 16:22:20]

It's not specific to DNS.  For example, UDPSocket class stores the same callback
as a member (to generate random port numbers when clients call Connect.)  Having
DNSQuery::RandomCallback as a type of a UDPSocket class member wouldn't be the
right thing, would it?

Anyway, I've moved the typedef to net/base/rand_callback.h.

+
 // Returns a random number in range [0, max).  Thread-safe.
 //
 // Note that this can be used as an adapter for std::random_shuffle():
 // Given a pre-populated |std::vector<int> myvector|, shuffle it as
 //   std::random_shuffle(myvector.begin(), myvector.end(), base::RandGenerator);
 BASE_API uint64 RandGenerator(uint64 max);
 
 // Returns a random double in range [0, 1). Thread-safe.
 BASE_API double RandDouble();
 
 // Given input |bits|, convert with maximum precision to a double in
 // the range [0, 1). Thread-safe.
 BASE_API double BitsToOpenEndedUnitInterval(uint64 bits);
 
 // Fills |output_length| bytes of |output| with cryptographically strong random
 // data.
 BASE_API void RandBytes(void* output, size_t output_length);
 
 // Fills a string of length |length| with with cryptographically strong random
 // data and returns it.
 //
 // Not that this is a variation of |RandBytes| with a different return type.
 BASE_API std::string RandBytesAsString(size_t length);
 
 }  // namespace base
 
 #endif  // BASE_RAND_UTIL_H_