[Extensions] Code Cleanup - Remove redundant smart-ptr get()s

chrome/browser/extensions/api/downloads/downloads_api.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 "chrome/browser/extensions/api/downloads/downloads_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <set>
@@ skipping 495 matching lines @@
   // comparisons.
   static base::LazyInstance<FilterTypeMap> filter_types =
     LAZY_INSTANCE_INITIALIZER;
   if (filter_types.Get().empty())
     InitFilterTypeMap(filter_types.Pointer());
 
   DownloadQuery query_out;
 
   size_t limit = 1000;
   if (query_in.limit.get()) {
-    if (*query_in.limit.get() < 0) {
+    if (*query_in.limit < 0) {
       *error = errors::kInvalidQueryLimit;
       return;
     }
-    limit = *query_in.limit.get();
+    limit = *query_in.limit;
   }
   if (limit > 0) {
     query_out.Limit(limit);
   }
 
   std::string state_string = downloads::ToString(query_in.state);
   if (!state_string.empty()) {
     DownloadItem::DownloadState state = StateEnumFromString(state_string);
     if (state == DownloadItem::MAX_DOWNLOAD_STATE) {
       *error = errors::kInvalidState;
       return;
     }
     query_out.AddFilter(state);
   }
   std::string danger_string =
       downloads::ToString(query_in.danger);
   if (!danger_string.empty()) {
     content::DownloadDangerType danger_type = DangerEnumFromString(
         danger_string);
     if (danger_type == content::DOWNLOAD_DANGER_TYPE_MAX) {
       *error = errors::kInvalidDangerType;
       return;
     }
     query_out.AddFilter(danger_type);
   }
   if (query_in.order_by.get()) {
-    CompileDownloadQueryOrderBy(*query_in.order_by.get(), error, &query_out);
+    CompileDownloadQueryOrderBy(*query_in.order_by, error, &query_out);
     if (!error->empty())
       return;
   }
 
   std::unique_ptr<base::DictionaryValue> query_in_value(query_in.ToValue());
-  for (base::DictionaryValue::Iterator query_json_field(*query_in_value.get());
+  for (base::DictionaryValue::Iterator query_json_field(*query_in_value);
        !query_json_field.IsAtEnd(); query_json_field.Advance()) {
     FilterTypeMap::const_iterator filter_type =
         filter_types.Get().find(query_json_field.key());
     if (filter_type != filter_types.Get().end()) {
       if (!query_out.AddFilter(filter_type->second, query_json_field.value())) {
         *error = errors::kInvalidFilter;
         return;
       }
     }
   }
 
   DownloadQuery::DownloadVector all_items;
   if (query_in.id.get()) {
-    DownloadItem* download_item = manager->GetDownload(*query_in.id.get());
+    DownloadItem* download_item = manager->GetDownload(*query_in.id);
     if (!download_item && incognito_manager)
-      download_item = incognito_manager->GetDownload(*query_in.id.get());
+      download_item = incognito_manager->GetDownload(*query_in.id);
     if (download_item)
       all_items.push_back(download_item);
   } else {
     manager->GetAllDownloads(&all_items);
     if (incognito_manager)
       incognito_manager->GetAllDownloads(&all_items);
   }
   query_out.AddFilter(base::Bind(&IsNotTemporaryDownloadFilter));
   query_out.Search(all_items.begin(), all_items.end(), results);
 }
@@ skipping 38 matching lines @@
     download_item->SetUserData(kKey, this);
   }
 
   ~ExtensionDownloadsEventRouterData() override {
     if (updated_ > 0) {
       UMA_HISTOGRAM_PERCENTAGE("Download.OnChanged",
                                (changed_fired_ * 100 / updated_));
     }
   }
 
-  const base::DictionaryValue& json() const { return *json_.get(); }
+  const base::DictionaryValue& json() const { return *json_; }
   void set_json(std::unique_ptr<base::DictionaryValue> json_item) {
     json_ = std::move(json_item);
   }
 
   void OnItemUpdated() { ++updated_; }
   void OnChangedFired() { ++changed_fired_; }
 
   static void SetDetermineFilenameTimeoutSecondsForTesting(int s) {
     determine_filename_timeout_s_ = s;
   }
@@ skipping 344 matching lines @@
 #if defined(OS_WIN)
     // Can't get filename16 from options.ToValue() because that converts it from
     // std::string.
     base::DictionaryValue* options_value = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options_value));
     base::string16 filename16;
     EXTENSION_FUNCTION_VALIDATE(options_value->GetString(
         kFilenameKey, &filename16));
     creator_suggested_filename = base::FilePath(filename16);
 #elif defined(OS_POSIX)
-    creator_suggested_filename = base::FilePath(*options.filename.get());
+    creator_suggested_filename = base::FilePath(*options.filename);
 #endif
     if (!net::IsSafePortableRelativePath(creator_suggested_filename)) {
       error_ = errors::kInvalidFilename;
       return false;
     }
   }
 
   if (options.save_as.get())
-    download_params->set_prompt(*options.save_as.get());
+    download_params->set_prompt(*options.save_as);
 
   if (options.headers.get()) {
     for (const downloads::HeaderNameValuePair& name_value : *options.headers) {
       if (!net::HttpUtil::IsValidHeaderName(name_value.name)) {
         error_ = errors::kInvalidHeaderName;
         return false;
       }
       if (!net::HttpUtil::IsSafeHeader(name_value.name)) {
         error_ = errors::kInvalidHeaderUnsafe;
         return false;
       }
       if (!net::HttpUtil::IsValidHeaderValue(name_value.value)) {
         error_ = errors::kInvalidHeaderValue;
         return false;
       }
       download_params->add_request_header(name_value.name, name_value.value);
     }
   }
 
   std::string method_string =
       downloads::ToString(options.method);
   if (!method_string.empty())
     download_params->set_method(method_string);
   if (options.body.get())
-    download_params->set_post_body(*options.body.get());
+    download_params->set_post_body(*options.body);
   download_params->set_callback(base::Bind(
       &DownloadsDownloadFunction::OnStarted, this,
       creator_suggested_filename, options.conflict_action));
   // Prevent login prompts for 401/407 responses.
   download_params->set_do_not_prompt_for_login(true);
 
   DownloadManager* manager = BrowserContext::GetDownloadManager(
       current_profile);
   manager->DownloadUrl(std::move(download_params));
   RecordDownloadSource(DOWNLOAD_INITIATED_BY_EXTENSION);
@@ skipping 437 matching lines @@
 }
 
 bool DownloadsGetFileIconFunction::RunAsync() {
   std::unique_ptr<downloads::GetFileIcon::Params> params(
       downloads::GetFileIcon::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const downloads::GetFileIconOptions* options =
       params->options.get();
   int icon_size = kDefaultIconSize;
   if (options && options->size.get())
-    icon_size = *options->size.get();
+    icon_size = *options->size;
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(download_item->GetTargetFilePath().empty(),
             errors::kEmptyFile, &error_))
     return false;
   // In-progress downloads return the intermediate filename for GetFullPath()
   // which doesn't have the final extension. Therefore a good file icon can't be
   // found, so use GetTargetFilePath() instead.
   DCHECK(icon_extractor_.get());
@@ skipping 304 matching lines @@
       DownloadItemToJSON(download_item, profile_));
   std::unique_ptr<base::DictionaryValue> delta(new base::DictionaryValue());
   delta->SetInteger(kIdKey, download_item->GetId());
   std::set<std::string> new_fields;
   bool changed = false;
 
   // For each field in the new json representation of the download_item except
   // the bytesReceived field, if the field has changed from the previous old
   // json, set the differences in the |delta| object and remember that something
   // significant changed.
-  for (base::DictionaryValue::Iterator iter(*new_json.get());
-       !iter.IsAtEnd(); iter.Advance()) {
+  for (base::DictionaryValue::Iterator iter(*new_json); !iter.IsAtEnd();
+       iter.Advance()) {
     new_fields.insert(iter.key());
     if (IsDownloadDeltaField(iter.key())) {
       const base::Value* old_value = NULL;
       if (!data->json().HasKey(iter.key()) ||
           (data->json().Get(iter.key(), &old_value) &&
            !iter.value().Equals(old_value))) {
         delta->Set(iter.key() + ".current", iter.value().DeepCopy());
         if (old_value)
           delta->Set(iter.key() + ".previous", old_value->DeepCopy());
         changed = true;
@@ skipping 89 matching lines @@
     return;
   base::Time now(base::Time::Now());
   int delta = now.ToTimeT() - last_checked_removal_.ToTimeT();
   if (delta <= kFileExistenceRateLimitSeconds)
     return;
   last_checked_removal_ = now;
   manager->CheckForHistoryFilesRemoval();
 }
 
 }  // namespace extensions