Cleanup: Remove deprecated base::Value methods from net. Use base::Value too.

net/socket/client_socket_pool_base.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/socket/client_socket_pool_base.h"
 
 #include <math.h>
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 95 matching lines @@
 void ConnectJob::set_socket(StreamSocket* socket) {
   if (socket) {
     net_log().AddEvent(NetLog::TYPE_CONNECT_JOB_SET_SOCKET,
                        socket->NetLog().source().ToEventParametersCallback());
   }
   socket_.reset(socket);
 }
 
 void ConnectJob::NotifyDelegateOfCompletion(int rv) {
   // The delegate will delete |this|.
-  Delegate *delegate = delegate_;
+  Delegate* delegate = delegate_;
   delegate_ = NULL;
 
   LogConnectCompletion(rv);
   delegate->OnConnectJobComplete(rv, this);
 }
 
 void ConnectJob::ResetTimer(base::TimeDelta remaining_time) {
   timer_.Stop();
   timer_.Start(FROM_HERE, remaining_time, this, &ConnectJob::OnTimeout);
 }
@@ skipping 455 matching lines @@
         // See http://crbug.com/5077.
         return LOAD_STATE_IDLE;
       }
     }
   }
 
   NOTREACHED();
   return LOAD_STATE_IDLE;
 }
 
-DictionaryValue* ClientSocketPoolBaseHelper::GetInfoAsValue(
+base::DictionaryValue* ClientSocketPoolBaseHelper::GetInfoAsValue(
     const std::string& name, const std::string& type) const {
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("name", name);
   dict->SetString("type", type);
   dict->SetInteger("handed_out_socket_count", handed_out_socket_count_);
   dict->SetInteger("connecting_socket_count", connecting_socket_count_);
   dict->SetInteger("idle_socket_count", idle_socket_count_);
   dict->SetInteger("max_socket_count", max_sockets_);
   dict->SetInteger("max_sockets_per_group", max_sockets_per_group_);
   dict->SetInteger("pool_generation_number", pool_generation_number_);
 
   if (group_map_.empty())
     return dict;
 
-  DictionaryValue* all_groups_dict = new DictionaryValue();
+  base::DictionaryValue* all_groups_dict = new base::DictionaryValue();
   for (GroupMap::const_iterator it = group_map_.begin();
        it != group_map_.end(); it++) {
     const Group* group = it->second;
-    DictionaryValue* group_dict = new DictionaryValue();
+    base::DictionaryValue* group_dict = new base::DictionaryValue();
 
     group_dict->SetInteger("pending_request_count",
                            group->pending_requests().size());
     if (!group->pending_requests().empty()) {
       group_dict->SetInteger("top_pending_priority",
                              group->TopPendingPriority());
     }
 
     group_dict->SetInteger("active_socket_count", group->active_socket_count());
 
-    ListValue* idle_socket_list = new ListValue();
+    base::ListValue* idle_socket_list = new base::ListValue();
     std::list<IdleSocket>::const_iterator idle_socket;
     for (idle_socket = group->idle_sockets().begin();
          idle_socket != group->idle_sockets().end();
          idle_socket++) {
       int source_id = idle_socket->socket->NetLog().source().id;
-      idle_socket_list->Append(Value::CreateIntegerValue(source_id));
+      idle_socket_list->Append(new base::FundamentalValue(source_id));
     }
     group_dict->Set("idle_sockets", idle_socket_list);
 
-    ListValue* connect_jobs_list = new ListValue();
+    base::ListValue* connect_jobs_list = new base::ListValue();
     std::set<ConnectJob*>::const_iterator job = group->jobs().begin();
     for (job = group->jobs().begin(); job != group->jobs().end(); job++) {
       int source_id = (*job)->net_log().source().id;
-      connect_jobs_list->Append(Value::CreateIntegerValue(source_id));
+      connect_jobs_list->Append(new base::FundamentalValue(source_id));
     }
     group_dict->Set("connect_jobs", connect_jobs_list);
 
     group_dict->SetBoolean("is_stalled",
                            group->IsStalledOnPoolMaxSockets(
                                max_sockets_per_group_));
     group_dict->SetBoolean("has_backup_job", group->HasBackupJob());
 
     all_groups_dict->SetWithoutPathExpansion(it->first, group_dict);
   }
@@ skipping 592 matching lines @@
   STLDeleteElements(&jobs_);
   unassigned_job_count_ = 0;
 
   // Cancel pending backup job.
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace internal
 
 }  // namespace net