Cleanup nits in content_setting*model.

chrome/browser/ui/content_settings/content_setting_bubble_model.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/ui/content_settings/content_setting_bubble_model.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 107 matching lines @@
   SetManageText();
   SetCustomLink();
 }
 
 ContentSettingSimpleBubbleModel*
     ContentSettingSimpleBubbleModel::AsSimpleBubbleModel() {
   return this;
 }
 
 void ContentSettingSimpleBubbleModel::SetTitle() {
-  TabSpecificContentSettings* content_settings = NULL;
-  if (web_contents()) {
-    content_settings =
-        TabSpecificContentSettings::FromWebContents(web_contents());
-  }
+  TabSpecificContentSettings* content_settings =
+      web_contents()
+          ? TabSpecificContentSettings::FromWebContents(web_contents())
+          : nullptr;
 
   static const ContentSettingsTypeIdEntry kBlockedTitleIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_TITLE},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_TITLE},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_TITLE},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_TITLE},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_TITLE},
     {CONTENT_SETTINGS_TYPE_MIXEDSCRIPT,
         IDS_BLOCKED_DISPLAYING_INSECURE_CONTENT},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER,
         IDS_BLOCKED_PPAPI_BROKER_TITLE},
     {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOAD_TITLE},
   };
   // Fields as for kBlockedTitleIDs, above.
   static const ContentSettingsTypeIdEntry kAccessedTitleIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_ACCESSED_COOKIES_TITLE},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_ALLOWED_PPAPI_BROKER_TITLE},
     {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_ALLOWED_DOWNLOAD_TITLE},
   };
-  const ContentSettingsTypeIdEntry *title_ids = kBlockedTitleIDs;
+  const ContentSettingsTypeIdEntry* title_ids = kBlockedTitleIDs;
   size_t num_title_ids = arraysize(kBlockedTitleIDs);
   if (content_settings && content_settings->IsContentAllowed(content_type()) &&
       !content_settings->IsContentBlocked(content_type())) {
     title_ids = kAccessedTitleIDs;
     num_title_ids = arraysize(kAccessedTitleIDs);
   }
-  int title_id =
-      GetIdForContentType(title_ids, num_title_ids, content_type());
+  int title_id = GetIdForContentType(title_ids, num_title_ids, content_type());
   if (title_id)
     set_title(l10n_util::GetStringUTF16(title_id));
 }
 
 void ContentSettingSimpleBubbleModel::SetManageText() {
   static const ContentSettingsTypeIdEntry kLinkIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_LINK},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_LINK},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_LINK},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_LINK},
@@ skipping 48 matching lines @@
   bool settings_changed() const;
   int selected_item() const { return selected_item_; }
 
  private:
   void SetRadioGroup();
   void SetNarrowestContentSetting(ContentSetting setting);
   void OnRadioClicked(int radio_index) override;
 
   ContentSetting block_setting_;
   int selected_item_;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingSingleRadioGroup);
 };
 
 ContentSettingSingleRadioGroup::ContentSettingSingleRadioGroup(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : ContentSettingSimpleBubbleModel(delegate,
                                       web_contents,
                                       profile,
@@ skipping 21 matching lines @@
 // content type and setting the default value based on the content setting.
 void ContentSettingSingleRadioGroup::SetRadioGroup() {
   GURL url = web_contents()->GetURL();
   base::string16 display_host =
       url_formatter::FormatUrlForSecurityDisplay(url);
   if (display_host.empty())
     display_host = base::ASCIIToUTF16(url.spec());
 
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
-  bool allowed =
-      !content_settings->IsContentBlocked(content_type());
-  DCHECK(!allowed ||
-         content_settings->IsContentAllowed(content_type()));
+  bool allowed = !content_settings->IsContentBlocked(content_type());
+  DCHECK(!allowed || content_settings->IsContentAllowed(content_type()));
 
   RadioGroup radio_group;
   radio_group.url = url;
 
   static const ContentSettingsTypeIdEntry kBlockedAllowIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_UNBLOCK_ALL},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_UNBLOCK},
@@ skipping 81 matching lines @@
   } else if (setting == CONTENT_SETTING_ALLOW) {
     radio_group.default_item = kAllowButtonIndex;
     // |block_setting_| is already set to |CONTENT_SETTING_BLOCK|.
   } else {
     radio_group.default_item = 1;
     block_setting_ = setting;
   }
 
   set_setting_is_managed(setting_source != SETTING_SOURCE_USER &&
                          setting != CONTENT_SETTING_ASK);
-  if (setting_source != SETTING_SOURCE_USER) {
-    set_radio_group_enabled(false);
-  } else {
-    set_radio_group_enabled(true);
-  }
+  set_radio_group_enabled(setting_source == SETTING_SOURCE_USER);
   selected_item_ = radio_group.default_item;
   set_radio_group(radio_group);
 }
 
 void ContentSettingSingleRadioGroup::SetNarrowestContentSetting(
     ContentSetting setting) {
-  if (profile()) {
-    HostContentSettingsMapFactory::GetForProfile(profile())
-        ->SetNarrowestContentSetting(bubble_content().radio_group.url,
-                                     bubble_content().radio_group.url,
-                                     content_type(), setting);
-  }
+  if (!profile())
+    return;
+
+  auto* map = HostContentSettingsMapFactory::GetForProfile(profile());
+  map->SetNarrowestContentSetting(bubble_content().radio_group.url,
+                                  bubble_content().radio_group.url,
+                                  content_type(), setting);
 }
 
 void ContentSettingSingleRadioGroup::OnRadioClicked(int radio_index) {
   selected_item_ = radio_index;
 }
 
 // ContentSettingCookiesBubbleModel --------------------------------------------
 
 class ContentSettingCookiesBubbleModel : public ContentSettingSingleRadioGroup {
  public:
   ContentSettingCookiesBubbleModel(Delegate* delegate,
                                    WebContents* web_contents,
                                    Profile* profile);
-
   ~ContentSettingCookiesBubbleModel() override;
 
  private:
   void OnCustomLinkClicked() override;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingCookiesBubbleModel);
 };
 
 ContentSettingCookiesBubbleModel::ContentSettingCookiesBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile)
     : ContentSettingSingleRadioGroup(delegate,
                                      web_contents,
                                      profile,
                                      CONTENT_SETTINGS_TYPE_COOKIES) {
@@ skipping 28 matching lines @@
                                   WebContents* web_contents,
                                   Profile* profile);
 
   ~ContentSettingPluginBubbleModel() override;
 
  private:
   void OnLearnMoreLinkClicked() override;
   void OnCustomLinkClicked() override;
 
   void RunPluginsOnPage();
+
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingPluginBubbleModel);
 };
 
 ContentSettingPluginBubbleModel::ContentSettingPluginBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile)
     : ContentSettingSingleRadioGroup(delegate,
                                      web_contents,
                                      profile,
                                      CONTENT_SETTINGS_TYPE_PLUGINS) {
@@ skipping 79 matching lines @@
                                  WebContents* web_contents,
                                  Profile* profile);
   ~ContentSettingPopupBubbleModel() override {}
 
  private:
   void OnListItemClicked(int index) override;
 
   int32_t item_id_from_item_index(int index) const {
     return bubble_content().list_items[index].item_id;
   }
+
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingPopupBubbleModel);
 };
 
 ContentSettingPopupBubbleModel::ContentSettingPopupBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile)
     : ContentSettingSingleRadioGroup(delegate,
                                      web_contents,
                                      profile,
                                      CONTENT_SETTINGS_TYPE_POPUPS) {
-  if (web_contents) {
-    // Build blocked popup list.
-    std::map<int32_t, GURL> blocked_popups =
-        PopupBlockerTabHelper::FromWebContents(web_contents)
-            ->GetBlockedPopupRequests();
-    for (const std::pair<int32_t, GURL>& blocked_popup : blocked_popups) {
-      std::string title(blocked_popup.second.spec());
-      // The pop-up may not have a valid URL.
-      if (title.empty())
-        title = l10n_util::GetStringUTF8(IDS_TAB_LOADING_TITLE);
-      ListItem popup_item(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-                              IDR_DEFAULT_FAVICON),
-                          title, true, blocked_popup.first);
-      add_list_item(popup_item);
-    }
+  if (!web_contents)
+    return;
+
+  // Build blocked popup list.
+  auto* helper = PopupBlockerTabHelper::FromWebContents(web_contents);
+  std::map<int32_t, GURL> blocked_popups = helper->GetBlockedPopupRequests();
+  for (const std::pair<int32_t, GURL>& blocked_popup : blocked_popups) {
+    std::string title(blocked_popup.second.spec());
+    // The pop-up may not have a valid URL.
+    if (title.empty())
+      title = l10n_util::GetStringUTF8(IDS_TAB_LOADING_TITLE);
+    ListItem popup_item(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+                            IDR_DEFAULT_FAVICON),
+                        title, true, blocked_popup.first);
+    add_list_item(popup_item);
   }
 }
 
 void ContentSettingPopupBubbleModel::OnListItemClicked(int index) {
   if (web_contents()) {
-    PopupBlockerTabHelper::FromWebContents(web_contents())
-        ->ShowBlockedPopup(item_id_from_item_index(index));
+    auto* helper = PopupBlockerTabHelper::FromWebContents(web_contents());
+    helper->ShowBlockedPopup(item_id_from_item_index(index));
   }
 }
 
 // ContentSettingMediaStreamBubbleModel ----------------------------------------
 
 ContentSettingMediaStreamBubbleModel::ContentSettingMediaStreamBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile)
     : ContentSettingBubbleModel(delegate, web_contents, profile),
@@ skipping 21 matching lines @@
   SetManageText();
   SetCustomLink();
 }
 
 ContentSettingMediaStreamBubbleModel::~ContentSettingMediaStreamBubbleModel() {
   // On some platforms (e.g. MacOS X) it is possible to close a tab while the
   // media stream bubble is open. This resets the web contents to NULL.
   if (!web_contents())
     return;
 
-  for (const std::pair<content::MediaStreamType, MediaMenu>& media_menu :
-       bubble_content().media_menus) {
-    if (media_menu.second.selected_device.id !=
-        media_menu.second.default_device.id) {
-      UpdateDefaultDeviceForType(media_menu.first,
-                                 media_menu.second.selected_device.id);
-    }
+  for (const auto& media_menu : bubble_content().media_menus) {
+    const MediaMenu& menu = media_menu.second;
+    if (menu.selected_device.id != menu.default_device.id)
+      UpdateDefaultDeviceForType(media_menu.first, menu.selected_device.id);
   }
 
   // Update the media settings if the radio button selection was changed.
-  if (selected_item_ != bubble_content().radio_group.default_item) {
+  if (selected_item_ != bubble_content().radio_group.default_item)
     UpdateSettings(radio_item_setting_[selected_item_]);
-  }
 }
 
 ContentSettingMediaStreamBubbleModel*
     ContentSettingMediaStreamBubbleModel::AsMediaStreamBubbleModel() {
   return this;
 }
 
 void ContentSettingMediaStreamBubbleModel::OnManageLinkClicked() {
   if (!delegate())
     return;
@@ skipping 95 matching lines @@
   radio_group.default_item = selected_item_;
   radio_group.radio_items.push_back(radio_allow_label);
   radio_group.radio_items.push_back(radio_block_label);
 
   set_radio_group(radio_group);
   set_radio_group_enabled(true);
 }
 
 void ContentSettingMediaStreamBubbleModel::UpdateSettings(
     ContentSetting setting) {
-  if (profile()) {
-    TabSpecificContentSettings* tab_content_settings =
-        TabSpecificContentSettings::FromWebContents(web_contents());
-    // The same urls must be used as in other places (e.g. the infobar) in
-    // order to override the existing rule. Otherwise a new rule is created.
-    // TODO(markusheintz): Extract to a helper so that there is only a single
-    // place to touch.
-    HostContentSettingsMap* map =
-        HostContentSettingsMapFactory::GetForProfile(profile());
-    if (MicrophoneAccessed()) {
-      PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
-          profile(), tab_content_settings->media_stream_access_origin(), GURL(),
-          CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-          PermissionSourceUI::PAGE_ACTION);
-      map->SetContentSettingDefaultScope(
-          tab_content_settings->media_stream_access_origin(), GURL(),
-          CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, std::string(), setting);
-    }
-    if (CameraAccessed()) {
-      PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
-          profile(), tab_content_settings->media_stream_access_origin(), GURL(),
-          CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-          PermissionSourceUI::PAGE_ACTION);
-      map->SetContentSettingDefaultScope(
-          tab_content_settings->media_stream_access_origin(), GURL(),
-          CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, std::string(), setting);
-    }
+  if (!profile())
+    return;
+
+  TabSpecificContentSettings* tab_content_settings =
+      TabSpecificContentSettings::FromWebContents(web_contents());
+  // The same urls must be used as in other places (e.g. the infobar) in
+  // order to override the existing rule. Otherwise a new rule is created.
+  // TODO(markusheintz): Extract to a helper so that there is only a single
+  // place to touch.
+  HostContentSettingsMap* map =
+      HostContentSettingsMapFactory::GetForProfile(profile());
+  if (MicrophoneAccessed()) {
+    PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
+        profile(), tab_content_settings->media_stream_access_origin(), GURL(),
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, PermissionSourceUI::PAGE_ACTION);
+    map->SetContentSettingDefaultScope(
+        tab_content_settings->media_stream_access_origin(), GURL(),
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, std::string(), setting);
+  }
+  if (CameraAccessed()) {
+    PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
+        profile(), tab_content_settings->media_stream_access_origin(), GURL(),
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+        PermissionSourceUI::PAGE_ACTION);
+    map->SetContentSettingDefaultScope(
+        tab_content_settings->media_stream_access_origin(), GURL(),
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, std::string(), setting);
   }
 }
 
 void ContentSettingMediaStreamBubbleModel::UpdateDefaultDeviceForType(
     content::MediaStreamType type,
     const std::string& device) {
   PrefService* prefs = profile()->GetPrefs();
   if (type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
     prefs->SetString(prefs::kDefaultAudioCaptureDevice, device);
   } else {
@@ skipping 119 matching lines @@
   ContentSettingDomainListBubbleModel(Delegate* delegate,
                                       WebContents* web_contents,
                                       Profile* profile,
                                       ContentSettingsType content_type);
   ~ContentSettingDomainListBubbleModel() override {}
 
  private:
   void MaybeAddDomainList(const std::set<std::string>& hosts, int title_id);
   void SetDomainsAndCustomLink();
   void OnCustomLinkClicked() override;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingDomainListBubbleModel);
 };
 
 ContentSettingDomainListBubbleModel::ContentSettingDomainListBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : ContentSettingSimpleBubbleModel(
         delegate, web_contents, profile, content_type) {
   DCHECK_EQ(CONTENT_SETTINGS_TYPE_GEOLOCATION, content_type) <<
@@ skipping 66 matching lines @@
     : public ContentSettingSimpleBubbleModel {
  public:
   ContentSettingMixedScriptBubbleModel(Delegate* delegate,
                                        WebContents* web_contents,
                                        Profile* profile);
 
   ~ContentSettingMixedScriptBubbleModel() override {}
 
  private:
   void OnCustomLinkClicked() override;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingMixedScriptBubbleModel);
 };
 
 ContentSettingMixedScriptBubbleModel::ContentSettingMixedScriptBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile)
     : ContentSettingSimpleBubbleModel(
           delegate,
           web_contents,
           profile,
@@ skipping 94 matching lines @@
   set_radio_group_enabled(true);
   set_radio_group(radio_group);
 }
 
 ContentSettingRPHBubbleModel::~ContentSettingRPHBubbleModel() {
   if (!web_contents() || !interacted_)
     return;
 
   // The user has one chance to deal with the RPH content setting UI,
   // then we remove it.
-  TabSpecificContentSettings::FromWebContents(web_contents())->
-      ClearPendingProtocolHandler();
+  auto* settings = TabSpecificContentSettings::FromWebContents(web_contents());
+  settings->ClearPendingProtocolHandler();
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
       content::Source<WebContents>(web_contents()),
       content::NotificationService::NoDetails());
 }
 
 void ContentSettingRPHBubbleModel::OnRadioClicked(int radio_index) {
   if (selected_item_ == radio_index)
     return;
 
@@ skipping 25 matching lines @@
   registry_->OnAcceptRegisterProtocolHandler(pending_handler_);
   TabSpecificContentSettings::FromWebContents(web_contents())->
       set_pending_protocol_handler_setting(CONTENT_SETTING_ALLOW);
 }
 
 void ContentSettingRPHBubbleModel::UnregisterProtocolHandler() {
   if (!web_contents())
     return;
 
   registry_->OnDenyRegisterProtocolHandler(pending_handler_);
-  TabSpecificContentSettings::FromWebContents(web_contents())->
-      set_pending_protocol_handler_setting(CONTENT_SETTING_BLOCK);
+  auto* settings = TabSpecificContentSettings::FromWebContents(web_contents());
+  settings->set_pending_protocol_handler_setting(CONTENT_SETTING_BLOCK);
   ClearOrSetPreviousHandler();
 }
 
 void ContentSettingRPHBubbleModel::IgnoreProtocolHandler() {
   if (!web_contents())
     return;
 
   registry_->OnIgnoreRegisterProtocolHandler(pending_handler_);
-  TabSpecificContentSettings::FromWebContents(web_contents())->
-      set_pending_protocol_handler_setting(CONTENT_SETTING_DEFAULT);
+  auto* settings = TabSpecificContentSettings::FromWebContents(web_contents());
+  settings->set_pending_protocol_handler_setting(CONTENT_SETTING_DEFAULT);
   ClearOrSetPreviousHandler();
 }
 
 void ContentSettingRPHBubbleModel::ClearOrSetPreviousHandler() {
   if (previous_handler_.IsEmpty()) {
     registry_->ClearDefault(pending_handler_.protocol());
   } else {
     registry_->OnAcceptRegisterProtocolHandler(previous_handler_);
   }
 }
@@ skipping 48 matching lines @@
  public:
   ContentSettingMidiSysExBubbleModel(Delegate* delegate,
                                      WebContents* web_contents,
                                      Profile* profile);
   ~ContentSettingMidiSysExBubbleModel() override {}
 
  private:
   void MaybeAddDomainList(const std::set<std::string>& hosts, int title_id);
   void SetDomainsAndCustomLink();
   void OnCustomLinkClicked() override;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingMidiSysExBubbleModel);
 };
 
 ContentSettingMidiSysExBubbleModel::ContentSettingMidiSysExBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile)
     : ContentSettingSimpleBubbleModel(delegate,
                                       web_contents,
                                       profile,
                                       CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
@@ skipping 149 matching lines @@
 
 ContentSettingBubbleModel::BubbleContent::~BubbleContent() {}
 
 void ContentSettingBubbleModel::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
     DCHECK_EQ(web_contents_,
               content::Source<WebContents>(source).ptr());
-    web_contents_ = NULL;
+    web_contents_ = nullptr;
   } else {
     DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
     DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
-    profile_ = NULL;
+    profile_ = nullptr;
   }
 }
 
 ContentSettingSimpleBubbleModel*
     ContentSettingBubbleModel::AsSimpleBubbleModel() {
   // In general, bubble models might not inherit from the simple bubble model.
   return nullptr;
 }
 
 ContentSettingMediaStreamBubbleModel*
     ContentSettingBubbleModel::AsMediaStreamBubbleModel() {
   // In general, bubble models might not inherit from the media bubble model.
   return nullptr;
 }
 
 ContentSettingSubresourceFilterBubbleModel*
 ContentSettingBubbleModel::AsSubresourceFilterBubbleModel() {
   return nullptr;
 }