Code review changes.

6 files changed, 51 insertions, 41 deletions

diff --git a/src/core/ext/client_config/client_channel.c b/src/core/ext/client_config/client_channel.c
index 0d243768ef..0594c0b3ac 100644
--- a/src/core/ext/client_config/client_channel.c
+++ b/src/core/ext/client_config/client_channel.c
@@ -663,9 +663,13 @@ static bool pick_subchannel(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
     // If the application explicitly set wait_for_ready, use that.
     // Otherwise, if the service config specified a value for this
     // method, use that.
-    if ((initial_metadata_flags &
-         GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET) == 0 &&
-        calld->wait_for_ready_from_service_config != WAIT_FOR_READY_UNSET) {
+    const bool wait_for_ready_set_from_api =
+        initial_metadata_flags &
+        GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET;
+    const bool wait_for_ready_set_from_service_config =
+        calld->wait_for_ready_from_service_config != WAIT_FOR_READY_UNSET;
+    if (!wait_for_ready_set_from_api &&
+        wait_for_ready_set_from_service_config) {
       if (calld->wait_for_ready_from_service_config == WAIT_FOR_READY_TRUE) {
         initial_metadata_flags |= GRPC_INITIAL_METADATA_WAIT_FOR_READY;
       } else {
@@ -676,8 +680,9 @@ static bool pick_subchannel(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
     const grpc_lb_policy_pick_args inputs = {
         calld->pollent, initial_metadata, initial_metadata_flags,
         &calld->lb_token_mdelem, gpr_inf_future(GPR_CLOCK_MONOTONIC)};
-    bool result = grpc_lb_policy_pick(exec_ctx, lb_policy, &inputs,
-                                      connected_subchannel, NULL, on_ready);
+    const bool result =
+        grpc_lb_policy_pick(exec_ctx, lb_policy, &inputs,
+                            connected_subchannel, NULL, on_ready);
     GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "pick_subchannel");
     GPR_TIMER_END("pick_subchannel", 0);
     return result;
@@ -836,13 +841,13 @@ static void read_service_config(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_mu_unlock(&chand->mu);
   // If the method config table was present, use it.
   if (method_config_table != NULL) {
-    grpc_method_config *method_config =
+    const grpc_method_config *method_config =
         grpc_method_config_table_get_method_config(method_config_table,
                                                    calld->path);
     if (method_config != NULL) {
-      gpr_timespec *per_method_timeout =
+      const gpr_timespec *per_method_timeout =
           grpc_method_config_get_timeout(method_config);
-      bool *wait_for_ready =
+      const bool *wait_for_ready =
           grpc_method_config_get_wait_for_ready(method_config);
       if (per_method_timeout != NULL || wait_for_ready != NULL) {
         gpr_mu_lock(&calld->mu);
@@ -907,14 +912,14 @@ static grpc_error *cc_init_call_elem(grpc_exec_ctx *exec_ctx,
           grpc_method_config_table_get_method_config(method_config_table,
                                                      args->path);
       if (method_config != NULL) {
-        gpr_timespec *per_method_timeout =
+        const gpr_timespec *per_method_timeout =
             grpc_method_config_get_timeout(method_config);
         if (per_method_timeout != NULL) {
           gpr_timespec per_method_deadline =
               gpr_time_add(calld->call_start_time, *per_method_timeout);
           calld->deadline = gpr_time_min(calld->deadline, per_method_deadline);
         }
-        bool *wait_for_ready =
+        const bool *wait_for_ready =
             grpc_method_config_get_wait_for_ready(method_config);
         if (wait_for_ready != NULL) {
           calld->wait_for_ready_from_service_config =
diff --git a/src/core/ext/client_config/method_config.c b/src/core/ext/client_config/method_config.c
index a112355ff5..3699c22810 100644
--- a/src/core/ext/client_config/method_config.c
+++ b/src/core/ext/client_config/method_config.c
@@ -174,29 +174,30 @@ void grpc_method_config_unref(grpc_method_config* method_config) {
   }
 }
 
-int grpc_method_config_cmp(grpc_method_config* method_config1,
-                           grpc_method_config* method_config2) {
+int grpc_method_config_cmp(const grpc_method_config* method_config1,
+                           const grpc_method_config* method_config2) {
   return grpc_hash_table_cmp(method_config1->table, method_config2->table);
 }
 
-bool* grpc_method_config_get_wait_for_ready(grpc_method_config* method_config) {
+const bool* grpc_method_config_get_wait_for_ready(
+    const grpc_method_config* method_config) {
   return grpc_hash_table_get(method_config->table,
                              method_config->wait_for_ready_key);
 }
 
-gpr_timespec* grpc_method_config_get_timeout(
-    grpc_method_config* method_config) {
+const gpr_timespec* grpc_method_config_get_timeout(
+    const grpc_method_config* method_config) {
   return grpc_hash_table_get(method_config->table, method_config->timeout_key);
 }
 
-int32_t* grpc_method_config_get_max_request_message_bytes(
-    grpc_method_config* method_config) {
+const int32_t* grpc_method_config_get_max_request_message_bytes(
+    const grpc_method_config* method_config) {
   return grpc_hash_table_get(method_config->table,
                              method_config->max_request_message_bytes_key);
 }
 
-int32_t* grpc_method_config_get_max_response_message_bytes(
-    grpc_method_config* method_config) {
+const int32_t* grpc_method_config_get_max_response_message_bytes(
+    const grpc_method_config* method_config) {
   return grpc_hash_table_get(method_config->table,
                              method_config->max_response_message_bytes_key);
 }
@@ -244,13 +245,13 @@ void grpc_method_config_table_unref(grpc_method_config_table* table) {
   grpc_hash_table_unref(table);
 }
 
-int grpc_method_config_table_cmp(grpc_method_config_table* table1,
-                                 grpc_method_config_table* table2) {
+int grpc_method_config_table_cmp(const grpc_method_config_table* table1,
+                                 const grpc_method_config_table* table2) {
   return grpc_hash_table_cmp(table1, table2);
 }
 
 grpc_method_config* grpc_method_config_table_get_method_config(
-    grpc_method_config_table* table, grpc_mdstr* path) {
+    const grpc_method_config_table* table, const grpc_mdstr* path) {
   grpc_method_config* method_config = grpc_hash_table_get(table, path);
   // If we didn't find a match for the path, try looking for a wildcard
   // entry (i.e., change "/service/method" to "/service/*").
diff --git a/src/core/ext/client_config/method_config.h b/src/core/ext/client_config/method_config.h
index 65b34a768a..04e6bc8141 100644
--- a/src/core/ext/client_config/method_config.h
+++ b/src/core/ext/client_config/method_config.h
@@ -51,17 +51,19 @@ grpc_method_config* grpc_method_config_create(
 grpc_method_config* grpc_method_config_ref(grpc_method_config* method_config);
 void grpc_method_config_unref(grpc_method_config* method_config);
 
-int grpc_method_config_cmp(grpc_method_config* method_config1,
-                           grpc_method_config* method_config2);
+int grpc_method_config_cmp(const grpc_method_config* method_config1,
+                           const grpc_method_config* method_config2);
 
 /// These methods return NULL if the requested field is unset.
 /// The caller does NOT take ownership of the result.
-bool* grpc_method_config_get_wait_for_ready(grpc_method_config* method_config);
-gpr_timespec* grpc_method_config_get_timeout(grpc_method_config* method_config);
-int32_t* grpc_method_config_get_max_request_message_bytes(
-    grpc_method_config* method_config);
-int32_t* grpc_method_config_get_max_response_message_bytes(
-    grpc_method_config* method_config);
+const bool* grpc_method_config_get_wait_for_ready(
+    const grpc_method_config* method_config);
+const gpr_timespec* grpc_method_config_get_timeout(
+    const grpc_method_config* method_config);
+const int32_t* grpc_method_config_get_max_request_message_bytes(
+    const grpc_method_config* method_config);
+const int32_t* grpc_method_config_get_max_response_message_bytes(
+    const grpc_method_config* method_config);
 
 /// A table of method configs.
 typedef grpc_hash_table grpc_method_config_table;
@@ -82,13 +84,13 @@ grpc_method_config_table* grpc_method_config_table_ref(
     grpc_method_config_table* table);
 void grpc_method_config_table_unref(grpc_method_config_table* table);
 
-int grpc_method_config_table_cmp(grpc_method_config_table* table1,
-                                 grpc_method_config_table* table2);
+int grpc_method_config_table_cmp(const grpc_method_config_table* table1,
+                                 const grpc_method_config_table* table2);
 
 /// Returns NULL if the method has no config.
 /// Caller does NOT own a reference to the result.
 grpc_method_config* grpc_method_config_table_get_method_config(
-    grpc_method_config_table* table, grpc_mdstr* path);
+    const grpc_method_config_table* table, const grpc_mdstr* path);
 
 /// Returns a channel arg containing \a table.
 grpc_arg grpc_method_config_table_create_channel_arg(
diff --git a/src/core/lib/channel/message_size_filter.c b/src/core/lib/channel/message_size_filter.c
index dbd8afd465..1382f19945 100644
--- a/src/core/lib/channel/message_size_filter.c
+++ b/src/core/lib/channel/message_size_filter.c
@@ -137,14 +137,14 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
         grpc_method_config_table_get_method_config(chand->method_config_table,
                                                    args->path);
     if (method_config != NULL) {
-      int32_t* max_request_message_bytes =
+      const int32_t* max_request_message_bytes =
           grpc_method_config_get_max_request_message_bytes(method_config);
       if (max_request_message_bytes != NULL &&
           (*max_request_message_bytes < calld->max_send_size ||
            calld->max_send_size < 0)) {
         calld->max_send_size = *max_request_message_bytes;
       }
-      int32_t* max_response_message_bytes =
+      const int32_t* max_response_message_bytes =
           grpc_method_config_get_max_response_message_bytes(method_config);
       if (max_response_message_bytes != NULL &&
           (*max_response_message_bytes < calld->max_recv_size ||
diff --git a/src/core/lib/transport/hashtable.c b/src/core/lib/transport/hashtable.c
index 838fe1026e..d127f17a37 100644
--- a/src/core/lib/transport/hashtable.c
+++ b/src/core/lib/transport/hashtable.c
@@ -47,8 +47,8 @@ struct grpc_hash_table {
 
 // Helper function for insert and get operations that performs quadratic
 // probing (https://en.wikipedia.org/wiki/Quadratic_probing).
-static size_t grpc_hash_table_find_index(grpc_hash_table* table,
-                                         grpc_mdstr* key, bool find_empty) {
+static size_t grpc_hash_table_find_index(
+    const grpc_hash_table* table, const grpc_mdstr* key, bool find_empty) {
   for (size_t i = 0; i < table->num_entries; ++i) {
     const size_t idx = (key->hash + i * i) % table->num_entries;
     if (table->entries[idx].key == NULL)
@@ -111,14 +111,15 @@ int grpc_hash_table_unref(grpc_hash_table* table) {
   return 0;
 }
 
-void* grpc_hash_table_get(grpc_hash_table* table, grpc_mdstr* key) {
+void* grpc_hash_table_get(const grpc_hash_table* table, const grpc_mdstr* key) {
   const size_t idx =
       grpc_hash_table_find_index(table, key, false /* find_empty */);
   if (idx == table->num_entries) return NULL;  // Not found.
   return table->entries[idx].value;
 }
 
-int grpc_hash_table_cmp(grpc_hash_table* table1, grpc_hash_table* table2) {
+int grpc_hash_table_cmp(const grpc_hash_table* table1,
+                        const grpc_hash_table* table2) {
   // Compare by num_entries.
   if (table1->num_entries < table2->num_entries) return -1;
   if (table1->num_entries > table2->num_entries) return 1;
diff --git a/src/core/lib/transport/hashtable.h b/src/core/lib/transport/hashtable.h
index 3ec48dce3a..0ce51383c7 100644
--- a/src/core/lib/transport/hashtable.h
+++ b/src/core/lib/transport/hashtable.h
@@ -74,9 +74,10 @@ int grpc_hash_table_unref(grpc_hash_table* table);
 
 /** Returns the value from \a table associated with \a key.
     Returns NULL if \a key is not found. */
-void* grpc_hash_table_get(grpc_hash_table* table, grpc_mdstr* key);
+void* grpc_hash_table_get(const grpc_hash_table* table, const grpc_mdstr* key);
 
 /** Compares two hash tables. */
-int grpc_hash_table_cmp(grpc_hash_table* table1, grpc_hash_table* table2);
+int grpc_hash_table_cmp(const grpc_hash_table* table1,
+                        const grpc_hash_table* table2);
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_HASHTABLE_H */