Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

content/browser/devtools/devtools_protocol.cc

 // Copyright (c) 2013 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 "content/browser/devtools/devtools_protocol.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/stringprintf.h"
 
@@ skipping 36 matching lines @@
     domain_ = method.substr(0, pos);
 }
 
 DevToolsProtocol::Command::~Command() {
 }
 
 std::string DevToolsProtocol::Command::Serialize() {
   DictionaryValue command;
   command.SetInteger(kIdParam, id_);
   command.SetString(kMethodParam, method_);
-  if (params_.get())
+  if (params_)
     command.Set(kParamsParam, params_->DeepCopy());
 
   std::string json_command;
   base::JSONWriter::Write(&command, &json_command);
   return json_command;
 }
 
 scoped_ptr<DevToolsProtocol::Response>
 DevToolsProtocol::Command::SuccessResponse(DictionaryValue* result) {
   return scoped_ptr<DevToolsProtocol::Response>(
@@ skipping 32 matching lines @@
 
   if (id_ != kNoId)
     response.SetInteger(kIdParam, id_);
 
   if (error_code_) {
     DictionaryValue* error_object = new DictionaryValue();
     response.Set(kErrorParam, error_object);
     error_object->SetInteger(kErrorCodeParam, error_code_);
     if (!error_message_.empty())
       error_object->SetString(kErrorMessageParam, error_message_);
-  } else if (result_.get()) {
+  } else if (result_) {
     response.Set(kResultParam, result_->DeepCopy());
   }
 
   std::string json_response;
   base::JSONWriter::Write(&response, &json_response);
   return json_response;
 }
 
 DevToolsProtocol::Response::Response(int id, DictionaryValue* result)
     : id_(id),
@@ skipping 17 matching lines @@
                                              DictionaryValue* params)
     : Message(method, params) {
 }
 
 DevToolsProtocol::Notification::~Notification() {
 }
 
 std::string DevToolsProtocol::Notification::Serialize() {
   DictionaryValue notification;
   notification.SetString(kMethodParam, method_);
-  if (params_.get())
+  if (params_)
     notification.Set(kParamsParam, params_->DeepCopy());
 
   std::string json_notification;
   base::JSONWriter::Write(&notification, &json_notification);
   return json_notification;
 }
 
 DevToolsProtocol::Handler::~Handler() {
 }
 
@@ skipping 98 matching lines @@
     Response response(0, kErrorParseError, error_message);
     if (error_response)
       *error_response = response.Serialize();
     return NULL;
   }
 
   return static_cast<DictionaryValue*>(message.release());
 }
 
 }  // namespace content