Remove unused on_new_block

`on_new_block` does nothing after removing `on_epoch_begin`

Author: foriequal0

core/src/block.rs

@@ -149,8 +149,6 @@ impl<'x> OpenBlock<'x> {
         engine.machine().populate_from_parent(&mut r.block.header, parent);
         engine.populate_from_parent(&mut r.block.header, parent);
 
-        engine.on_new_block(&mut r.block)?;
-
         Ok(r)
     }
 

core/src/consensus/mod.rs

@@ -221,11 +221,6 @@ pub trait ConsensusEngine: Sync + Send {
     /// Stops any services that the may hold the Engine and makes it safe to drop.
     fn stop(&self) {}
 
-    /// Block transformation functions, before the transactions.
-    fn on_new_block(&self, _block: &mut ExecutedBlock) -> Result<(), Error> {
-        Ok(())
-    }
-
     /// Block transformation functions, after the transactions.
     fn on_close_block(&self, _block: &mut ExecutedBlock) -> Result<(), Error> {
         Ok(())

core/src/consensus/tendermint/engine.rs

@@ -143,17 +143,6 @@ impl ConsensusEngine for Tendermint {
 
     fn stop(&self) {}
 
-    fn on_new_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
-        let (result, receiver) = crossbeam::bounded(1);
-        self.inner
-            .send(worker::Event::OnNewBlock {
-                header: Box::from(block.header().clone()),
-                result,
-            })
-            .unwrap();
-        receiver.recv().unwrap()
-    }
-
     fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
         let author = *block.header().author();
         let (total_fee, min_fee) = {

core/src/consensus/tendermint/worker.rs

@@ -117,10 +117,6 @@ pub enum Event {
         result: crossbeam::Sender<U256>,
     },
     OnTimeout(usize),
-    OnNewBlock {
-        header: Box<Header>,
-        result: crossbeam::Sender<Result<(), Error>>,
-    },
     HandleMessages {
         messages: Vec<Vec<u8>>,
         result: crossbeam::Sender<Result<(), EngineError>>,
@@ -266,12 +262,6 @@ impl Worker {
                             Ok(Event::OnTimeout(token)) => {
                                 inner.on_timeout(token);
                             }
-                            Ok(Event::OnNewBlock {
-                                header,
-                                result,
-                            }) => {
-                                result.send(inner.on_new_block(&header)).unwrap();
-                            }
                             Ok(Event::HandleMessages {
                                 messages,
                                 result,
@@ -1254,10 +1244,6 @@ impl Worker {
         nonce < self.timeout_token_nonce
     }
 
-    fn on_new_block(&self, _header: &Header) -> Result<(), Error> {
-        Ok(())
-    }
-
     fn handle_message(&mut self, rlp: &[u8], is_restoring: bool) -> Result<(), EngineError> {
         fn fmt_err<T: ::std::fmt::Debug>(x: T) -> EngineError {
             EngineError::MalformedMessage(format!("{:?}", x))