QUIC - minor cleanup changes.

net/quic/reliable_quic_stream.cc

 // Copyright (c) 2012 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.
 
 #include "net/quic/reliable_quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
@@ skipping 315 matching lines @@
           delegate->WroteData(false);
         }
       }
       break;
     }
   }
 }
 
 void ReliableQuicStream::MaybeSendBlocked() {
   flow_controller_.MaybeSendBlocked();
-  if (stream_contributes_to_connection_flow_control_) {
-    connection_flow_controller_->MaybeSendBlocked();
+  if (!stream_contributes_to_connection_flow_control_) {
+    return;
   }
+  connection_flow_controller_->MaybeSendBlocked();
   // If we are connection level flow control blocked, then add the stream
   // to the write blocked list. It will be given a chance to write when a
   // connection level WINDOW_UPDATE arrives.
-  if (stream_contributes_to_connection_flow_control_ &&
-      connection_flow_controller_->IsBlocked() &&
+  if (connection_flow_controller_->IsBlocked() &&
       !flow_controller_.IsBlocked()) {
     session_->MarkWriteBlocked(id(), EffectivePriority());
   }
 }
 
 QuicConsumedData ReliableQuicStream::WritevData(
     const struct iovec* iov,
     int iov_count,
     bool fin,
     QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
@@ skipping 129 matching lines @@
     // We can write again!
     // TODO(rjshade): This does not respect priorities (e.g. multiple
     //                outstanding POSTs are unblocked on arrival of
     //                SHLO with initial window).
     // As long as the connection is not flow control blocked, we can write!
     OnCanWrite();
   }
 }
 
 bool ReliableQuicStream::MaybeIncreaseHighestReceivedOffset(uint64 new_offset) {
-  if (flow_controller_.IsEnabled()) {
-    uint64 increment =
-        new_offset - flow_controller_.highest_received_byte_offset();
-    if (flow_controller_.UpdateHighestReceivedOffset(new_offset)) {
-      // If |new_offset| increased the stream flow controller's highest received
-      // offset, then we need to increase the connection flow controller's value
-      // by the incremental difference.
-      if (stream_contributes_to_connection_flow_control_) {
-        connection_flow_controller_->UpdateHighestReceivedOffset(
-            connection_flow_controller_->highest_received_byte_offset() +
-            increment);
-      }
-      return true;
-    }
+  if (!flow_controller_.IsEnabled()) {
+    return false;
   }
-  return false;
+  uint64 increment =
+      new_offset - flow_controller_.highest_received_byte_offset();
+  if (!flow_controller_.UpdateHighestReceivedOffset(new_offset)) {
+    return false;
+  }
+
+  // If |new_offset| increased the stream flow controller's highest received
+  // offset, then we need to increase the connection flow controller's value
+  // by the incremental difference.
+  if (stream_contributes_to_connection_flow_control_) {
+    connection_flow_controller_->UpdateHighestReceivedOffset(
+        connection_flow_controller_->highest_received_byte_offset() +
+        increment);
+  }
+  return true;
 }
 
 void ReliableQuicStream::AddBytesSent(uint64 bytes) {
   if (flow_controller_.IsEnabled()) {
     flow_controller_.AddBytesSent(bytes);
     if (stream_contributes_to_connection_flow_control_) {
       connection_flow_controller_->AddBytesSent(bytes);
     }
   }
 }
 
 void ReliableQuicStream::AddBytesConsumed(uint64 bytes) {
   if (flow_controller_.IsEnabled()) {
     // Only adjust stream level flow controller if we are still reading.
     if (!read_side_closed_) {
       flow_controller_.AddBytesConsumed(bytes);
     }
 
     if (stream_contributes_to_connection_flow_control_) {
       connection_flow_controller_->AddBytesConsumed(bytes);
     }
   }
 }
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
-  bool stream_flow_control_blocked = flow_controller_.IsBlocked();
-  bool connecton_flow_control_blocked =
-      stream_contributes_to_connection_flow_control_ &&
+  if (flow_controller_.IsBlocked()) {
+    return true;
+  }
+  return stream_contributes_to_connection_flow_control_ &&
       connection_flow_controller_->IsBlocked();
-  return stream_flow_control_blocked || connecton_flow_control_blocked;
 }
 
 }  // namespace net