openpgp: Rename every from_buffered_reader to from_cookie_reader.

  - This is an internal interface that uses our reader stack's
    cookie.  We need this to traverse the buffered reader stack.  We
    did not, however, expose it as an external interface, because we
    didn't want to bake in the cookie type into the API.

  - Having a public API that operates on buffered readers is
    convenient: the current Parser::from_reader operates on
    io::Readers, and will most likely construct a
    buffered_reader::Generic from it.  This will eagerly buffer some
    data, making this interface unsuitable if you want to read in one
    artifact (e.g. an MPI) without consuming more data.

  - Renaming the internal functions gives us a chance to add a more
    general buffered reader interface.

11 files changed, 42 insertions, 42 deletions

diff --git a/openpgp/src/armor.rs b/openpgp/src/armor.rs
index 7d0baa2a..97e82d1e 100644
--- a/openpgp/src/armor.rs
+++ b/openpgp/src/armor.rs
@@ -621,7 +621,7 @@ impl<'a> Reader<'a> {
         where R: 'a + Read + Send + Sync,
               M: Into<Option<ReaderMode>>
     {
-        Self::from_buffered_reader(
+        Self::from_cookie_reader(
             Box::new(buffered_reader::Generic::with_cookie(inner, None,
                                                            Default::default())),
             mode, Default::default())
@@ -703,7 +703,7 @@ impl<'a> Reader<'a> {
         where R: 'a + Read + Send + Sync,
               M: Into<Option<ReaderMode>>
     {
-        Self::from_buffered_reader(
+        Self::from_cookie_reader(
             Box::new(buffered_reader::Generic::with_cookie(reader, None,
                                                            Default::default())),
             mode, Default::default())
@@ -714,7 +714,7 @@ impl<'a> Reader<'a> {
         where P: AsRef<Path>,
               M: Into<Option<ReaderMode>>
     {
-        Ok(Self::from_buffered_reader(
+        Ok(Self::from_cookie_reader(
             Box::new(buffered_reader::File::with_cookie(path,
                                                         Default::default())?),
             mode, Default::default()))
@@ -724,21 +724,21 @@ impl<'a> Reader<'a> {
     pub fn from_bytes<M>(bytes: &'a [u8], mode: M) -> Self
         where M: Into<Option<ReaderMode>>
     {
-        Self::from_buffered_reader(
+        Self::from_cookie_reader(
             Box::new(buffered_reader::Memory::with_cookie(bytes,
                                                           Default::default())),
             mode, Default::default())
     }
 
-    pub(crate) fn from_buffered_reader<M>(
+    pub(crate) fn from_cookie_reader<M>(
         inner: Box<dyn BufferedReader<Cookie> + 'a>, mode: M, cookie: Cookie)
         -> Self
         where M: Into<Option<ReaderMode>>
     {
-        Self::from_buffered_reader_csft(inner, mode.into(), cookie, false)
+        Self::from_cookie_reader_csft(inner, mode.into(), cookie, false)
     }
 
-    pub(crate) fn from_buffered_reader_csft(
+    pub(crate) fn from_cookie_reader_csft(
         inner: Box<dyn BufferedReader<Cookie> + 'a>,
         mode: Option<ReaderMode>,
         cookie: Cookie,
@@ -2324,7 +2324,7 @@ mod test {
                 -> crate::Result<()>
         where R: AsRef<[u8]>
         {
-            let mut reader = Reader::from_buffered_reader_csft(
+            let mut reader = Reader::from_cookie_reader_csft(
                 Box::new(buffered_reader::Memory::with_cookie(
                     clearsig, Default::default())),
                 None, Default::default(), true);
@@ -2354,7 +2354,7 @@ mod test {
 
             // If we parse it without enabling the CSF transformation,
             // we should only find the signature.
-            let mut reader = Reader::from_buffered_reader_csft(
+            let mut reader = Reader::from_cookie_reader_csft(
                 Box::new(buffered_reader::Memory::with_cookie(
                     clearsig, Default::default())),
                 None, Default::default(), false);
diff --git a/openpgp/src/cert/parser/mod.rs b/openpgp/src/cert/parser/mod.rs
index eea20d49..147f32de 100644
--- a/openpgp/src/cert/parser/mod.rs
+++ b/openpgp/src/cert/parser/mod.rs
@@ -521,7 +521,7 @@ impl<'a> From<PacketParserResult<'a>> for CertParser<'a>
                     tracer!(TRACE, "PacketParserResult::next", 0);
                     if let Some(reader) = retry_with_reader.take() {
                         // Try to find the next (armored) blob.
-                        match PacketParser::from_buffered_reader(reader) {
+                        match PacketParser::from_cookie_reader(reader) {
                             Ok(PacketParserResult::Some(pp)) => {
                                 // We read at least one packet.  Try
                                 // to parse the next cert.
diff --git a/openpgp/src/cert/raw.rs b/openpgp/src/cert/raw.rs
index f999e66d..e9610818 100644
--- a/openpgp/src/cert/raw.rs
+++ b/openpgp/src/cert/raw.rs
@@ -617,7 +617,7 @@ impl<'a> RawCertParser<'a> {
         let mut reader = dup.into_boxed().into_inner().expect("inner");
 
         if dearmor {
-            reader = armor::Reader::from_buffered_reader(
+            reader = armor::Reader::from_cookie_reader(
                 reader, armor::ReaderMode::Tolerant(None),
                 Default::default()).into_boxed();
 
@@ -709,7 +709,7 @@ impl<'a> Iterator for RawCertParser<'a>
             let reader = reader.into_inner().expect("the armor reader");
 
             // and install a new one!
-            self.reader = armor::Reader::from_buffered_reader(
+            self.reader = armor::Reader::from_cookie_reader(
                 reader, armor::ReaderMode::Tolerant(None),
                 Default::default()).into_boxed();
         }
diff --git a/openpgp/src/crypto/aead.rs b/openpgp/src/crypto/aead.rs
index ae81cbf7..4cf0cfd1 100644
--- a/openpgp/src/crypto/aead.rs
+++ b/openpgp/src/crypto/aead.rs
@@ -262,13 +262,13 @@ impl<'a, S: Schedule> Decryptor<'a, S> {
         -> Result<Self>
         where R: io::Read + Send + Sync + 'a
     {
-        Self::from_buffered_reader(
+        Self::from_cookie_reader(
             sym_algo, aead, chunk_size, schedule, key,
             Box::new(buffered_reader::Generic::with_cookie(
                 source, None, Default::default())))
     }
 
-    pub fn from_buffered_reader(sym_algo: SymmetricAlgorithm,
+    pub fn from_cookie_reader(sym_algo: SymmetricAlgorithm,
                             aead: AEADAlgorithm, chunk_size: usize,
                             schedule: S, key: SessionKey,
                             source: Box<dyn 'a + BufferedReader<Cookie>>)
@@ -488,7 +488,7 @@ impl<'a, S: Schedule> BufferedReaderDecryptor<'a, S> {
     {
         Ok(BufferedReaderDecryptor {
             reader: buffered_reader::Generic::with_cookie(
-                Decryptor::from_buffered_reader(
+                Decryptor::from_cookie_reader(
                     sym_algo, aead, chunk_size, schedule, key, source)?,
                 None, cookie),
         })
diff --git a/openpgp/src/crypto/mem.rs b/openpgp/src/crypto/mem.rs
index 5c0580da..7d6c6869 100644
--- a/openpgp/src/crypto/mem.rs
+++ b/openpgp/src/crypto/mem.rs
@@ -418,7 +418,7 @@ mod has_access_to_prekey {
             let mut plaintext = Protected::new(self.plaintext_len);
 
             let mut decryptor =
-                aead::Decryptor::from_buffered_reader(
+                aead::Decryptor::from_cookie_reader(
                                      SYMMETRIC_ALGO,
                                      AEAD_ALGO,
                                      self.plaintext_len,
diff --git a/openpgp/src/crypto/symmetric.rs b/openpgp/src/crypto/symmetric.rs
index 0652497c..97789e09 100644
--- a/openpgp/src/crypto/symmetric.rs
+++ b/openpgp/src/crypto/symmetric.rs
@@ -60,14 +60,14 @@ impl<'a> Decryptor<'a> {
     where
         R: io::Read + Send + Sync + 'a,
     {
-        Self::from_buffered_reader(
+        Self::from_cookie_reader(
             algo, key,
             Box::new(buffered_reader::Generic::with_cookie(
                 source, None, Default::default())))
     }
 
     /// Instantiate a new symmetric decryptor.
-    fn from_buffered_reader(algo: SymmetricAlgorithm, key: &[u8],
+    fn from_cookie_reader(algo: SymmetricAlgorithm, key: &[u8],
                             source: Box<dyn BufferedReader<Cookie> + 'a>)
                             -> Result<Self>
     {
@@ -182,7 +182,7 @@ impl<'a> BufferedReaderDecryptor<'a> {
     {
         Ok(BufferedReaderDecryptor {
             reader: buffered_reader::Generic::with_cookie(
-                Decryptor::from_buffered_reader(algo, key, reader)?,
+                Decryptor::from_cookie_reader(algo, key, reader)?,
                 None, cookie),
         })
     }
diff --git a/openpgp/src/packet_pile.rs b/openpgp/src/packet_pile.rs
index fe45e736..f62eb6f6 100644
--- a/openpgp/src/packet_pile.rs
+++ b/openpgp/src/packet_pile.rs
@@ -136,7 +136,7 @@ impl<'a> Parse<'a, PacketPile> for PacketPile {
     fn from_reader<R: 'a + io::Read + Send + Sync>(reader: R) -> Result<PacketPile> {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
-        PacketPile::from_buffered_reader(Box::new(bio))
+        PacketPile::from_cookie_reader(Box::new(bio))
     }
 
     /// Deserializes the OpenPGP message stored in the file named by
@@ -144,7 +144,7 @@ impl<'a> Parse<'a, PacketPile> for PacketPile {
     ///
     /// See `from_reader` for more details and caveats.
     fn from_file<P: AsRef<Path>>(path: P) -> Result<PacketPile> {
-        PacketPile::from_buffered_reader(
+        PacketPile::from_cookie_reader(
             Box::new(buffered_reader::File::with_cookie(path, Cookie::default())?))
     }
 
@@ -154,7 +154,7 @@ impl<'a> Parse<'a, PacketPile> for PacketPile {
     fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D) -> Result<PacketPile> {
         let bio = buffered_reader::Memory::with_cookie(
             data.as_ref(), Cookie::default());
-        PacketPile::from_buffered_reader(Box::new(bio))
+        PacketPile::from_cookie_reader(Box::new(bio))
     }
 }
 
@@ -504,9 +504,9 @@ impl PacketPile {
     }
 
 
-    pub(crate) fn from_buffered_reader<'a>(bio: Box<dyn BufferedReader<Cookie> + 'a>)
+    pub(crate) fn from_cookie_reader<'a>(bio: Box<dyn BufferedReader<Cookie> + 'a>)
             -> Result<PacketPile> {
-        PacketParserBuilder::from_buffered_reader(bio)?
+        PacketParserBuilder::from_cookie_reader(bio)?
             .buffer_unread_content()
             .into_packet_pile()
     }
diff --git a/openpgp/src/parse.rs b/openpgp/src/parse.rs
index 1ecf63b2..1b2333a0 100644
--- a/openpgp/src/parse.rs
+++ b/openpgp/src/parse.rs
@@ -4002,9 +4002,9 @@ impl <'a> PacketParser<'a> {
     ///
     /// This function returns a `PacketParser` for the first packet in
     /// the stream.
-    pub(crate) fn from_buffered_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>)
+    pub(crate) fn from_cookie_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>)
             -> Result<PacketParserResult<'a>> {
-        PacketParserBuilder::from_buffered_reader(bio)?.build()
+        PacketParserBuilder::from_cookie_reader(bio)?.build()
     }
 
     /// Returns the reader stack, replacing it with a
diff --git a/openpgp/src/parse/packet_parser_builder.rs b/openpgp/src/parse/packet_parser_builder.rs
index 7427da59..02a83ad3 100644
--- a/openpgp/src/parse/packet_parser_builder.rs
+++ b/openpgp/src/parse/packet_parser_builder.rs
@@ -102,7 +102,7 @@ impl<'a> Parse<'a, PacketParserBuilder<'a>> for PacketParserBuilder<'a> {
     /// Creates a `PacketParserBuilder` for an OpenPGP message stored
     /// in a `std::io::Read` object.
     fn from_reader<R: io::Read + 'a + Send + Sync>(reader: R) -> Result<Self> {
-        PacketParserBuilder::from_buffered_reader(
+        PacketParserBuilder::from_cookie_reader(
             Box::new(buffered_reader::Generic::with_cookie(
                 reader, None, Cookie::default())))
     }
@@ -110,14 +110,14 @@ impl<'a> Parse<'a, PacketParserBuilder<'a>> for PacketParserBuilder<'a> {
     /// Creates a `PacketParserBuilder` for an OpenPGP message stored
     /// in the file named `path`.
     fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
-        PacketParserBuilder::from_buffered_reader(
+        PacketParserBuilder::from_cookie_reader(
             Box::new(buffered_reader::File::with_cookie(path, Cookie::default())?))
     }
 
     /// Creates a `PacketParserBuilder` for an OpenPGP message stored
     /// in the specified buffer.
     fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D) -> Result<PacketParserBuilder<'a>> {
-        PacketParserBuilder::from_buffered_reader(
+        PacketParserBuilder::from_cookie_reader(
             Box::new(buffered_reader::Memory::with_cookie(
                 data.as_ref(), Cookie::default())))
     }
@@ -129,7 +129,7 @@ impl<'a> PacketParserBuilder<'a> {
     //
     // Note: this clears the `level` field of the
     // `Cookie` cookie.
-    pub(crate) fn from_buffered_reader(mut bio: Box<dyn BufferedReader<Cookie> + 'a>)
+    pub(crate) fn from_cookie_reader(mut bio: Box<dyn BufferedReader<Cookie> + 'a>)
             -> Result<Self> {
         bio.cookie_mut().level = None;
         Ok(PacketParserBuilder {
@@ -467,7 +467,7 @@ impl<'a> PacketParserBuilder<'a> {
             // Add a top-level filter so that it is peeled off when
             // the packet parser is finished.  We use level -2 for that.
             self.bio =
-                armor::Reader::from_buffered_reader_csft(self.bio, Some(mode),
+                armor::Reader::from_cookie_reader_csft(self.bio, Some(mode),
                     Cookie::new(ARMOR_READER_LEVEL), self.csf_transformation)
                 .into_boxed();
         }
diff --git a/openpgp/src/parse/packet_pile_parser.rs b/openpgp/src/parse/packet_pile_parser.rs
index 10c90ea0..ea65912e 100644
--- a/openpgp/src/parse/packet_pile_parser.rs
+++ b/openpgp/src/parse/packet_pile_parser.rs
@@ -224,14 +224,14 @@ impl<'a> Parse<'a, PacketPileParser<'a>> for PacketPileParser<'a> {
              -> Result<PacketPileParser<'a>> {
         let bio = Box::new(buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default()));
-        PacketPileParser::from_buffered_reader(bio)
+        PacketPileParser::from_cookie_reader(bio)
     }
 
     /// Creates a `PacketPileParser` to parse the OpenPGP message stored
     /// in the file named by `path`.
     fn from_file<P: AsRef<Path>>(path: P)
             -> Result<PacketPileParser<'a>> {
-        PacketPileParser::from_buffered_reader(
+        PacketPileParser::from_cookie_reader(
             Box::new(buffered_reader::File::with_cookie(path, Cookie::default())?))
     }
 
@@ -241,7 +241,7 @@ impl<'a> Parse<'a, PacketPileParser<'a>> for PacketPileParser<'a> {
             -> Result<PacketPileParser<'a>> {
         let bio = Box::new(buffered_reader::Memory::with_cookie(
             data.as_ref(), Cookie::default()));
-        PacketPileParser::from_buffered_reader(bio)
+        PacketPileParser::from_cookie_reader(bio)
     }
 }
 
@@ -259,9 +259,9 @@ impl<'a> PacketPileParser<'a> {
 
     /// Creates a `PacketPileParser` to parse the OpenPGP message stored
     /// in the `BufferedReader` object.
-    pub(crate) fn from_buffered_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>)
+    pub(crate) fn from_cookie_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>)
             -> Result<PacketPileParser<'a>> {
-        Self::from_packet_parser(PacketParser::from_buffered_reader(bio)?)
+        Self::from_packet_parser(PacketParser::from_cookie_reader(bio)?)
     }
 
     /// Inserts the next packet into the `PacketPile`.
diff --git a/openpgp/src/parse/stream.rs b/openpgp/src/parse/stream.rs
index 46188fd0..288df6ac 100644
--- a/openpgp/src/parse/stream.rs
+++ b/openpgp/src/parse/stream.rs
@@ -1259,7 +1259,7 @@ impl<'a> VerifierBuilder<'a> {
         // Do not eagerly map `t` to the current time.
         let t = time.into();
         Ok(Verifier {
-            decryptor: Decryptor::from_buffered_reader(
+            decryptor: Decryptor::from_cookie_reader(
                 policy,
                 self.message,
                 NoDecryptionHelper { v: helper, },
@@ -1605,7 +1605,7 @@ impl<'a> DetachedVerifierBuilder<'a> {
         // Do not eagerly map `t` to the current time.
         let t = time.into();
         Ok(DetachedVerifier {
-            decryptor: Decryptor::from_buffered_reader(
+            decryptor: Decryptor::from_cookie_reader(
                 policy,
                 self.signatures,
                 NoDecryptionHelper { v: helper, },
@@ -2047,7 +2047,7 @@ impl<'a> DecryptorBuilder<'a> {
     {
         // Do not eagerly map `t` to the current time.
         let t = time.into();
-        Decryptor::from_buffered_reader(
+        Decryptor::from_cookie_reader(
             policy,
             self.message,
             helper,
@@ -2322,7 +2322,7 @@ impl<'a, H: VerificationHelper + DecryptionHelper> Decryptor<'a, H> {
 
     /// Creates the `Decryptor`, and buffers the data up to `buffer_size`.
     #[allow(clippy::redundant_pattern_matching)]
-    fn from_buffered_reader<T>(
+    fn from_cookie_reader<T>(
         policy: &'a dyn Policy,
         bio: Box<dyn BufferedReader<Cookie> + 'a>,
         helper: H, time: T,
@@ -2334,7 +2334,7 @@ impl<'a, H: VerificationHelper + DecryptionHelper> Decryptor<'a, H> {
         -> Result<Decryptor<'a, H>>
         where T: Into<Option<time::SystemTime>>
     {
-        tracer!(TRACE, "Decryptor::from_buffered_reader", TRACE_INDENT);
+        tracer!(TRACE, "Decryptor::from_cookie_reader", TRACE_INDENT);
 
         let time = time.into();
         let tolerance = time
@@ -2343,7 +2343,7 @@ impl<'a, H: VerificationHelper + DecryptionHelper> Decryptor<'a, H> {
                 *crate::packet::signature::subpacket::CLOCK_SKEW_TOLERANCE);
         let time = time.unwrap_or_else(crate::now);
 
-        let mut ppr = PacketParserBuilder::from_buffered_reader(bio)?
+        let mut ppr = PacketParserBuilder::from_cookie_reader(bio)?
             .map(mapping)
             .csf_transformation(csf_transformation)
             .build()?;