Add SelectionData for tracking selections (#4725)

vwbaker · web-flow · commit ac88ecba1e78 · 2023-01-18T15:19:39.000+01:00
SelectionData contains the underlying data that any of the sampling tabs
may need.  This makes it easier and quicker to swap between the data of
a full capture, a selection, or an inspection.  The inspection isn't
taking full advantage of this data structure yet as it's still branched,
but I hope to change this in a future PR.

Bug: http://b/264437402
diff --git a/src/OrbitGl/CMakeLists.txt b/src/OrbitGl/CMakeLists.txt
@@ -58,6 +58,7 @@ target_sources(
          include/OrbitGl/SamplingReport.h
          include/OrbitGl/SchedulerTrack.h
          include/OrbitGl/SchedulingStats.h
+         include/OrbitGl/SelectionData.h
          include/OrbitGl/ShortenStringWithEllipsis.h
          include/OrbitGl/SimpleTimings.h
          include/OrbitGl/StaticTimeGraphLayout.h
@@ -133,6 +134,7 @@ target_sources(
           SamplingReport.cpp
           SchedulerTrack.cpp
           SchedulingStats.cpp
+          SelectionData.cpp
           SimpleTimings.cpp
           SymbolLoader.cpp
           SystemMemoryTrack.cpp
diff --git a/src/OrbitGl/CallstackThreadBar.cpp b/src/OrbitGl/CallstackThreadBar.cpp
@@ -151,7 +151,7 @@ void CallstackThreadBar::DoUpdatePrimitives(PrimitiveAssembler& primitive_assemb
       primitive_assembler.AddVerticalLine({pos_x, GetPos()[1]}, track_height, z, green_selection);
     };
     const orbit_client_data::CallstackData& selection_callstack_data =
-        capture_data_->selection_callstack_data();
+        app_->GetSelectedCallstackData();
     if (GetThreadId() == orbit_base::kAllProcessThreadsTid) {
       selection_callstack_data.ForEachCallstackEventInTimeRangeDiscretized(
           min_tick, max_tick, resolution_in_pixels, action_on_selected_callstack_events);
diff --git a/src/OrbitGl/OrbitApp.cpp b/src/OrbitGl/OrbitApp.cpp
@@ -186,6 +186,7 @@ constexpr const char* kWineSyscallDispatcherFunctionName = "__wine_syscall_dispa
 constexpr std::string_view kGgpVlkModulePathSubstring = "ggpvlk.so";
 const TimeRange kDefaultTimeRange =
     TimeRange(std::numeric_limits<uint64_t>::min(), std::numeric_limits<uint64_t>::max());
+const CallstackData kEmptyCallstackData;
 
 orbit_data_views::PresetLoadState GetPresetLoadStateForProcess(const PresetFile& preset,
                                                                const ProcessData* process) {
@@ -435,10 +436,13 @@ Future<void> OrbitApp::OnCaptureComplete() {
             std::move(post_processed_sampling_data));
         RefreshCaptureView();
 
-        SetSamplingReport(&GetCaptureData().GetCallstackData(),
-                          &GetCaptureData().post_processed_sampling_data());
-        SetTopDownView(GetCaptureData().post_processed_sampling_data());
-        SetBottomUpView(GetCaptureData().post_processed_sampling_data());
+        full_capture_selection_ = std::make_unique<SelectionData>(
+            *module_manager_, GetCaptureData(), GetCaptureData().post_processed_sampling_data(),
+            &GetCaptureData().GetCallstackData());
+        SetSamplingReport(&full_capture_selection_->GetCallstackData(),
+                          &full_capture_selection_->GetPostProcessedSamplingData());
+        main_window_->SetTopDownView(full_capture_selection_->GetTopDownView());
+        main_window_->SetBottomUpView(full_capture_selection_->GetBottomUpView());
 
         ORBIT_CHECK(capture_stopped_callback_);
         capture_stopped_callback_();
@@ -2249,7 +2253,6 @@ void OrbitApp::SetCaptureDataSelectionFields(
 }
 
 void OrbitApp::SelectCallstackEvents(absl::Span<const CallstackEvent> selected_callstack_events) {
-  main_window_->ClearCallstackInspection();
   SetCaptureDataSelectionFields(selected_callstack_events);
   SetSelectionTopDownView(GetCaptureData().selection_post_processed_sampling_data(),
                           GetCaptureData());
@@ -2261,16 +2264,13 @@ void OrbitApp::SelectCallstackEvents(absl::Span<const CallstackEvent> selected_c
 }
 
 void OrbitApp::InspectCallstackEvents(absl::Span<const CallstackEvent> selected_callstack_events) {
-  SetCaptureDataSelectionFields(selected_callstack_events);
-  main_window_->SetCallstackInspection(
-      CallTreeView::CreateTopDownViewFromPostProcessedSamplingData(
-          GetCaptureData().selection_post_processed_sampling_data(), *module_manager_,
-          GetCaptureData()),
-      CallTreeView::CreateBottomUpViewFromPostProcessedSamplingData(
-          GetCaptureData().selection_post_processed_sampling_data(), *module_manager_,
-          GetCaptureData()),
-      GetOrCreateSelectionCallstackDataView(), &GetCaptureData().selection_callstack_data(),
-      &GetCaptureData().selection_post_processed_sampling_data());
+  auto selection = std::make_unique<SelectionData>(*module_manager_, GetCaptureData(),
+                                                   selected_callstack_events);
+  main_window_->SetCallstackInspection(selection->GetTopDownView(), selection->GetBottomUpView(),
+                                       GetOrCreateDataView(DataViewType::kCallstack),
+                                       &selection->GetCallstackData(),
+                                       &selection->GetPostProcessedSamplingData());
+  inspection_selection_ = std::move(selection);
   FireRefreshCallbacks();
 }
 
@@ -2281,8 +2281,8 @@ void OrbitApp::ClearSelectionTabs() {
 }
 
 void OrbitApp::ClearInspection() {
-  SetCaptureDataSelectionFields(std::vector<CallstackEvent>());
   main_window_->ClearCallstackInspection();
+  inspection_selection_.reset();
   FireRefreshCallbacks();
 }
 
@@ -2297,10 +2297,18 @@ void OrbitApp::UpdateAfterSymbolLoading() {
       orbit_client_model::CreatePostProcessedSamplingData(capture_data.GetCallstackData(),
                                                           capture_data, *module_manager_);
   GetMutableCaptureData().set_post_processed_sampling_data(post_processed_sampling_data);
-  main_window_->UpdateSamplingReport(&capture_data.GetCallstackData(),
-                                     &capture_data.post_processed_sampling_data());
-  SetTopDownView(capture_data.post_processed_sampling_data());
-  SetBottomUpView(capture_data.post_processed_sampling_data());
+  auto selection = std::make_unique<SelectionData>(*module_manager_, GetCaptureData(),
+                                                   GetCaptureData().post_processed_sampling_data(),
+                                                   &GetCaptureData().GetCallstackData());
+  main_window_->SetTopDownView(selection->GetTopDownView());
+  main_window_->SetBottomUpView(selection->GetBottomUpView());
+  main_window_->UpdateSamplingReport(&selection->GetCallstackData(),
+                                     &selection->GetPostProcessedSamplingData());
+  full_capture_selection_ = std::move(selection);
+
+  main_window_->ClearCallstackInspection();
+  inspection_selection_.reset();
+  time_range_thread_selection_.reset();
 
   PostProcessedSamplingData selection_post_processed_sampling_data =
       orbit_client_model::CreatePostProcessedSamplingData(capture_data.selection_callstack_data(),
@@ -2788,12 +2796,12 @@ void OrbitApp::ClearTimeRangeSelection() {
 }
 
 void OrbitApp::ClearThreadAndTimeRangeSelection() {
-  SetCaptureDataSelectionFields(std::vector<CallstackEvent>());
   main_window_->SetLiveTabScopeStatsCollection(GetCaptureData().GetAllScopeStatsCollection());
-  SetTopDownView(GetCaptureData().post_processed_sampling_data());
-  SetBottomUpView(GetCaptureData().post_processed_sampling_data());
-  SetSamplingReport(&GetCaptureData().GetCallstackData(),
-                    &GetCaptureData().post_processed_sampling_data());
+  main_window_->SetTopDownView(full_capture_selection_->GetTopDownView());
+  main_window_->SetBottomUpView(full_capture_selection_->GetBottomUpView());
+  SetSamplingReport(&full_capture_selection_->GetCallstackData(),
+                    &full_capture_selection_->GetPostProcessedSamplingData());
+  time_range_thread_selection_.reset();
 
   FireRefreshCallbacks();
 }
@@ -2803,6 +2811,7 @@ void OrbitApp::OnThreadOrTimeRangeSelectionChange() {
   if (!HasCaptureData() || !absl::GetFlag(FLAGS_time_range_selection)) return;
 
   main_window_->ClearCallstackInspection();
+  inspection_selection_.reset();
 
   uint32_t thread_id = data_manager_->selected_thread_id();
   bool has_time_range = data_manager_->GetSelectionTimeRange().has_value();
@@ -2813,21 +2822,35 @@ void OrbitApp::OnThreadOrTimeRangeSelectionChange() {
 
   TimeRange time_range =
       has_time_range ? data_manager_->GetSelectionTimeRange().value() : kDefaultTimeRange;
+  std::vector<CallstackEvent> callstack_events;
   if (thread_id == kAllProcessThreadsTid) {
-    SetCaptureDataSelectionFields(GetCaptureData().GetCallstackData().GetCallstackEventsInTimeRange(
-        time_range.start, time_range.end));
+    callstack_events = GetCaptureData().GetCallstackData().GetCallstackEventsInTimeRange(
+        time_range.start, time_range.end);
   } else {
-    SetCaptureDataSelectionFields(
-        GetCaptureData().GetCallstackData().GetCallstackEventsOfTidInTimeRange(
-            thread_id, time_range.start, time_range.end));
+    callstack_events = GetCaptureData().GetCallstackData().GetCallstackEventsOfTidInTimeRange(
+        thread_id, time_range.start, time_range.end);
   }
-
+  auto selection =
+      std::make_unique<SelectionData>(*module_manager_, GetCaptureData(), callstack_events);
   main_window_->SetLiveTabScopeStatsCollection(
       GetCaptureData().CreateScopeStatsCollection(thread_id, time_range.start, time_range.end));
-  SetTopDownView(GetCaptureData().selection_post_processed_sampling_data());
-  SetBottomUpView(GetCaptureData().selection_post_processed_sampling_data());
-  SetSamplingReport(&GetCaptureData().selection_callstack_data(),
-                    &GetCaptureData().selection_post_processed_sampling_data());
+  main_window_->SetTopDownView(selection->GetTopDownView());
+  main_window_->SetBottomUpView(selection->GetBottomUpView());
+  SetSamplingReport(&selection->GetCallstackData(), &selection->GetPostProcessedSamplingData());
+  time_range_thread_selection_ = std::move(selection);
 
   FireRefreshCallbacks();
+}
+
+const CallstackData& OrbitApp::GetSelectedCallstackData() const {
+  if (absl::GetFlag(FLAGS_time_range_selection)) {
+    if (inspection_selection_ != nullptr) {
+      return inspection_selection_->GetCallstackData();
+    }
+    if (time_range_thread_selection_ != nullptr) {
+      return time_range_thread_selection_->GetCallstackData();
+    }
+    return kEmptyCallstackData;
+  }
+  return GetCaptureData().selection_callstack_data();
 }
diff --git a/src/OrbitGl/SelectionData.cpp b/src/OrbitGl/SelectionData.cpp
@@ -0,0 +1,43 @@
+
+// Copyright (c) 2023 The Orbit 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 "OrbitGl/SelectionData.h"
+
+#include <utility>
+
+#include "ClientData/CallstackData.h"
+#include "ClientData/CallstackEvent.h"
+#include "ClientModel/SamplingDataPostProcessor.h"
+
+using orbit_client_data::CallstackData;
+using orbit_client_data::CallstackEvent;
+using orbit_client_data::CaptureData;
+using orbit_client_data::ModuleManager;
+using orbit_client_data::PostProcessedSamplingData;
+
+SelectionData::SelectionData(const ModuleManager& module_manager, const CaptureData& capture_data,
+                             PostProcessedSamplingData post_processed_sampling_data,
+                             const CallstackData* callstack_data)
+    : post_processed_sampling_data_(std::move(post_processed_sampling_data)),
+      callstack_data_pointer_(callstack_data) {
+  top_down_view_ = CallTreeView::CreateTopDownViewFromPostProcessedSamplingData(
+      post_processed_sampling_data_, module_manager, capture_data);
+  bottom_up_view_ = CallTreeView::CreateBottomUpViewFromPostProcessedSamplingData(
+      post_processed_sampling_data_, module_manager, capture_data);
+}
+
+SelectionData::SelectionData(const ModuleManager& module_manager, const CaptureData& capture_data,
+                             absl::Span<const CallstackEvent> callstack_events) {
+  for (const CallstackEvent& event : callstack_events) {
+    callstack_data_object_.AddCallstackFromKnownCallstackData(event,
+                                                              capture_data.GetCallstackData());
+  }
+  post_processed_sampling_data_ = orbit_client_model::CreatePostProcessedSamplingData(
+      callstack_data_object_, capture_data, module_manager);
+  top_down_view_ = CallTreeView::CreateTopDownViewFromPostProcessedSamplingData(
+      post_processed_sampling_data_, module_manager, capture_data);
+  bottom_up_view_ = CallTreeView::CreateBottomUpViewFromPostProcessedSamplingData(
+      post_processed_sampling_data_, module_manager, capture_data);
+}
diff --git a/src/OrbitGl/include/OrbitGl/MainWindowInterface.h b/src/OrbitGl/include/OrbitGl/MainWindowInterface.h
@@ -79,7 +79,8 @@ class MainWindowInterface {
   virtual ~MainWindowInterface() = default;
 
   virtual void SetCallstackInspection(
-      std::unique_ptr<CallTreeView> top_down_view, std::unique_ptr<CallTreeView> bottom_up_view,
+      std::shared_ptr<const CallTreeView> top_down_view,
+      std::shared_ptr<const CallTreeView> bottom_up_view,
       orbit_data_views::DataView* callstack_data_view,
       const orbit_client_data::CallstackData* callstack_data,
       const orbit_client_data::PostProcessedSamplingData* post_processed_sampling_data) = 0;
@@ -91,10 +92,10 @@ class MainWindowInterface {
   virtual void SetLiveTabScopeStatsCollection(
       std::shared_ptr<const orbit_client_data::ScopeStatsCollection> scope_collection) = 0;
 
-  virtual void SetTopDownView(std::unique_ptr<CallTreeView> view) = 0;
-  virtual void SetBottomUpView(std::unique_ptr<CallTreeView> view) = 0;
-  virtual void SetSelectionTopDownView(std::unique_ptr<CallTreeView> view) = 0;
-  virtual void SetSelectionBottomUpView(std::unique_ptr<CallTreeView> view) = 0;
+  virtual void SetTopDownView(std::shared_ptr<const CallTreeView> view) = 0;
+  virtual void SetBottomUpView(std::shared_ptr<const CallTreeView> view) = 0;
+  virtual void SetSelectionTopDownView(std::shared_ptr<const CallTreeView> view) = 0;
+  virtual void SetSelectionBottomUpView(std::shared_ptr<const CallTreeView> view) = 0;
   virtual void SetSamplingReport(
       orbit_data_views::DataView* callstack_data_view,
       const orbit_client_data::CallstackData* callstack_data,
diff --git a/src/OrbitGl/include/OrbitGl/OrbitApp.h b/src/OrbitGl/include/OrbitGl/OrbitApp.h
@@ -83,6 +83,7 @@
 #include "OrbitGl/IntrospectionWindow.h"
 #include "OrbitGl/MainWindowInterface.h"
 #include "OrbitGl/ManualInstrumentationManager.h"
+#include "OrbitGl/SelectionData.h"
 #include "OrbitGl/SymbolLoader.h"
 #include "OrbitGl/TimeGraph.h"
 #include "PresetFile/PresetFile.h"
@@ -399,6 +400,8 @@ class OrbitApp final : public DataViewFactory,
   void ClearInspection();
   void ClearSelectionTabs();
 
+  const orbit_client_data::CallstackData& GetSelectedCallstackData() const;
+
   void SelectTracepoint(const orbit_grpc_protos::TracepointInfo& tracepoint) override;
   void DeselectTracepoint(const orbit_grpc_protos::TracepointInfo& tracepoint) override;
 
@@ -583,6 +586,10 @@ class OrbitApp final : public DataViewFactory,
   std::optional<orbit_gl::SymbolLoader> symbol_loader_;
   static constexpr std::chrono::milliseconds kMaxPostProcessingInterval{1000};
   orbit_qt_utils::Throttle update_after_symbol_loading_throttle_{kMaxPostProcessingInterval};
+
+  std::unique_ptr<SelectionData> full_capture_selection_;
+  std::unique_ptr<SelectionData> time_range_thread_selection_;
+  std::unique_ptr<SelectionData> inspection_selection_;
 };
 
 #endif  // ORBIT_GL_APP_H_
diff --git a/src/OrbitGl/include/OrbitGl/SelectionData.h b/src/OrbitGl/include/OrbitGl/SelectionData.h
@@ -0,0 +1,58 @@
+
+// Copyright (c) 2023 The Orbit Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CLIENT_DATA_SELECTION_DATA_H_
+#define CLIENT_DATA_SELECTION_DATA_H_
+
+#include "ClientData/CaptureData.h"
+#include "ClientData/ModuleManager.h"
+#include "ClientData/PostProcessedSamplingData.h"
+#include "OrbitGl/CallTreeView.h"
+
+// This is meant to hold the data needed to update the data tabs to a specific selection.
+class SelectionData {
+ public:
+  // Delete move/copy operators because callstack_data_pointer_ is pointing to a variable inside the
+  // class.
+  SelectionData(const SelectionData& other) = delete;
+  SelectionData& operator=(const SelectionData& other) = delete;
+  SelectionData(SelectionData&& other) = delete;
+  SelectionData& operator=(SelectionData&& other) = delete;
+
+  SelectionData(const orbit_client_data::ModuleManager& module_manager,
+                const orbit_client_data::CaptureData& capture_data,
+                orbit_client_data::PostProcessedSamplingData post_processed_sampling_data,
+                const orbit_client_data::CallstackData* callstack_data);
+
+  SelectionData(const orbit_client_data::ModuleManager& module_manager,
+                const orbit_client_data::CaptureData& capture_data,
+                absl::Span<const orbit_client_data::CallstackEvent> callstack_events);
+
+  std::shared_ptr<const CallTreeView> GetTopDownView() const { return top_down_view_; }
+
+  std::shared_ptr<const CallTreeView> GetBottomUpView() const { return bottom_up_view_; }
+
+  const orbit_client_data::PostProcessedSamplingData& GetPostProcessedSamplingData() const {
+    return post_processed_sampling_data_;
+  }
+
+  const orbit_client_data::CallstackData& GetCallstackData() const {
+    ORBIT_CHECK(callstack_data_pointer_);
+    return *callstack_data_pointer_;
+  }
+
+ private:
+  std::shared_ptr<CallTreeView> top_down_view_;
+  std::shared_ptr<CallTreeView> bottom_up_view_;
+
+  orbit_client_data::PostProcessedSamplingData post_processed_sampling_data_;
+
+  orbit_client_data::CallstackData callstack_data_object_;
+  // Depending on how SelectionData is created, this either points to callstack_data_object_ or to
+  // the CallstackData object passed into SelectionData.
+  const orbit_client_data::CallstackData* callstack_data_pointer_ = &callstack_data_object_;
+};
+
+#endif  // CLIENT_DATA_SELECTION_DATA_H_
diff --git a/src/OrbitQt/CallTreeViewItemModel.cpp b/src/OrbitQt/CallTreeViewItemModel.cpp
@@ -20,7 +20,7 @@
 #include "OrbitBase/Logging.h"
 #include "OrbitBase/ThreadConstants.h"
 
-CallTreeViewItemModel::CallTreeViewItemModel(std::unique_ptr<CallTreeView> call_tree_view,
+CallTreeViewItemModel::CallTreeViewItemModel(std::shared_ptr<const CallTreeView> call_tree_view,
                                              QObject* parent)
     : QAbstractItemModel{parent}, call_tree_view_{std::move(call_tree_view)} {}
 
@@ -362,7 +362,7 @@ QModelIndex CallTreeViewItemModel::index(int row, int column, const QModelIndex&
     return {};
   }
 
-  CallTreeNode* parent_item = nullptr;
+  const CallTreeNode* parent_item = nullptr;
   if (!parent.isValid()) {
     parent_item = call_tree_view_.get();
   } else {
diff --git a/src/OrbitQt/CallTreeWidget.cpp b/src/OrbitQt/CallTreeWidget.cpp
@@ -105,7 +105,7 @@ CallTreeWidget::CallTreeWidget(QWidget* parent)
 
 CallTreeWidget::~CallTreeWidget() = default;
 
-void CallTreeWidget::SetCallTreeView(std::unique_ptr<CallTreeView> call_tree_view,
+void CallTreeWidget::SetCallTreeView(std::shared_ptr<const CallTreeView> call_tree_view,
                                      std::unique_ptr<QIdentityProxyModel> hide_values_proxy_model) {
   ORBIT_CHECK(app_ != nullptr);
 
@@ -216,7 +216,7 @@ static void ExpandRecursivelyWithThreshold(QTreeView* tree_view, const QModelInd
   }
 }
 
-void CallTreeWidget::SetTopDownView(std::unique_ptr<CallTreeView> top_down_view) {
+void CallTreeWidget::SetTopDownView(std::shared_ptr<const CallTreeView> top_down_view) {
   // Expand recursively if CallTreeView contains information for a single thread.
   bool should_expand = IsSliderEnabled() && top_down_view->thread_count() == 1;
 
@@ -230,14 +230,14 @@ void CallTreeWidget::SetTopDownView(std::unique_ptr<CallTreeView> top_down_view)
   }
 }
 
-void CallTreeWidget::SetBottomUpView(std::unique_ptr<CallTreeView> bottom_up_view) {
+void CallTreeWidget::SetBottomUpView(std::shared_ptr<const CallTreeView> bottom_up_view) {
   SetCallTreeView(std::move(bottom_up_view),
                   std::make_unique<HideValuesForBottomUpProxyModel>(nullptr));
   // Don't show the "Exclusive" column for the bottom-up tree, it provides no useful information.
   ui_->callTreeTreeView->hideColumn(CallTreeViewItemModel::kExclusive);
 }
 
-void CallTreeWidget::SetInspection(std::unique_ptr<CallTreeView> call_tree_view) {
+void CallTreeWidget::SetInspection(std::shared_ptr<const CallTreeView> call_tree_view) {
   ORBIT_CHECK(hide_values_proxy_model_ != nullptr);
   ui_->inspectionNoticeWidget->show();
   inspection_model_ = std::make_unique<CallTreeViewItemModel>(std::move(call_tree_view));
diff --git a/src/OrbitQt/include/OrbitQt/CallTreeViewItemModel.h b/src/OrbitQt/include/OrbitQt/CallTreeViewItemModel.h
diff --git a/src/OrbitQt/include/OrbitQt/CallTreeWidget.h b/src/OrbitQt/include/OrbitQt/CallTreeWidget.h
diff --git a/src/OrbitQt/include/OrbitQt/orbitmainwindow.h b/src/OrbitQt/include/OrbitQt/orbitmainwindow.h
diff --git a/src/OrbitQt/orbitmainwindow.cpp b/src/OrbitQt/orbitmainwindow.cpp

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ CallTreeWidget::CallTreeWidget(QWidget* parent)`
`105`	`105`
`106`	`106`	`CallTreeWidget::~CallTreeWidget() = default;`
`107`	`107`
`108`		`-void CallTreeWidget::SetCallTreeView(std::unique_ptr<CallTreeView> call_tree_view,`
	`108`	`+void CallTreeWidget::SetCallTreeView(std::shared_ptr<const CallTreeView> call_tree_view,`
`109`	`109`	`std::unique_ptr<QIdentityProxyModel> hide_values_proxy_model) {`
`110`	`110`	`ORBIT_CHECK(app_ != nullptr);`
`111`	`111`
`@@ -216,7 +216,7 @@ static void ExpandRecursivelyWithThreshold(QTreeView* tree_view, const QModelInd`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
`219`		`-void CallTreeWidget::SetTopDownView(std::unique_ptr<CallTreeView> top_down_view) {`
	`219`	`+void CallTreeWidget::SetTopDownView(std::shared_ptr<const CallTreeView> top_down_view) {`
`220`	`220`	`// Expand recursively if CallTreeView contains information for a single thread.`
`221`	`221`	`bool should_expand = IsSliderEnabled() && top_down_view->thread_count() == 1;`
`222`	`222`
`@@ -230,14 +230,14 @@ void CallTreeWidget::SetTopDownView(std::unique_ptr<CallTreeView> top_down_view)`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`233`		`-void CallTreeWidget::SetBottomUpView(std::unique_ptr<CallTreeView> bottom_up_view) {`
	`233`	`+void CallTreeWidget::SetBottomUpView(std::shared_ptr<const CallTreeView> bottom_up_view) {`
`234`	`234`	`SetCallTreeView(std::move(bottom_up_view),`
`235`	`235`	`std::make_unique<HideValuesForBottomUpProxyModel>(nullptr));`
`236`	`236`	`// Don't show the "Exclusive" column for the bottom-up tree, it provides no useful information.`
`237`	`237`	`ui_->callTreeTreeView->hideColumn(CallTreeViewItemModel::kExclusive);`
`238`	`238`	`}`
`239`	`239`
`240`		`-void CallTreeWidget::SetInspection(std::unique_ptr<CallTreeView> call_tree_view) {`
	`240`	`+void CallTreeWidget::SetInspection(std::shared_ptr<const CallTreeView> call_tree_view) {`
`241`	`241`	`ORBIT_CHECK(hide_values_proxy_model_ != nullptr);`
`242`	`242`	`ui_->inspectionNoticeWidget->show();`
`243`	`243`	`inspection_model_ = std::make_unique<CallTreeViewItemModel>(std::move(call_tree_view));`