hists__calc_col_len(hists, h);
 }
 
-void hists__filter_by_dso(struct hists *hists, const struct dso *dso)
+void hists__filter_by_dso(struct hists *hists)
 {
        struct rb_node *nd;
 
                if (symbol_conf.exclude_other && !h->parent)
                        continue;
 
-               if (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) {
+               if (hists->dso_filter != NULL &&
+                   (h->ms.map == NULL || h->ms.map->dso != hists->dso_filter)) {
                        h->filtered |= (1 << HIST_FILTER__DSO);
                        continue;
                }
        }
 }
 
-void hists__filter_by_thread(struct hists *hists, const struct thread *thread)
+void hists__filter_by_thread(struct hists *hists)
 {
        struct rb_node *nd;
 
        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
-               if (thread != NULL && h->thread != thread) {
+               if (hists->thread_filter != NULL &&
+                   h->thread != hists->thread_filter) {
                        h->filtered |= (1 << HIST_FILTER__THREAD);
                        continue;
                }
 
        HISTC_NR_COLS, /* Last entry */
 };
 
+struct thread;
+struct dso;
+
 struct hists {
        struct rb_root          entries_in_array[2];
        struct rb_root          *entries_in;
        struct rb_root          entries;
        struct rb_root          entries_collapsed;
        u64                     nr_entries;
+       const struct thread     *thread_filter;
+       const struct dso        *dso_filter;
        pthread_mutex_t         lock;
        struct events_stats     stats;
        u64                     event_stream;
 int hist_entry__inc_addr_samples(struct hist_entry *self, int evidx, u64 addr);
 int hist_entry__annotate(struct hist_entry *self, size_t privsize);
 
-void hists__filter_by_dso(struct hists *self, const struct dso *dso);
-void hists__filter_by_thread(struct hists *self, const struct thread *thread);
+void hists__filter_by_dso(struct hists *hists);
+void hists__filter_by_thread(struct hists *hists);
 
 u16 hists__col_len(struct hists *self, enum hist_column col);
 void hists__set_col_len(struct hists *self, enum hist_column col, u16 len);
 
        struct hists        *hists;
        struct hist_entry   *he_selection;
        struct map_symbol   *selection;
-       const struct thread *thread_filter;
-       const struct dso    *dso_filter;
        bool                 has_symbols;
 };
 
 static int hists__browser_title(struct hists *self, char *bf, size_t size,
-                               const char *ev_name, const struct dso *dso,
-                               const struct thread *thread);
+                               const char *ev_name);
 
 static void hist_browser__refresh_dimensions(struct hist_browser *self)
 {
        self->b.nr_entries = self->hists->nr_entries;
 
        hist_browser__refresh_dimensions(self);
-       hists__browser_title(self->hists, title, sizeof(title), ev_name,
-                            self->dso_filter, self->thread_filter);
+       hists__browser_title(self->hists, title, sizeof(title), ev_name);
 
        if (ui_browser__show(&self->b, title,
                             "Press '?' for help on key bindings") < 0)
                        timer(arg);
                        ui_browser__update_nr_entries(&self->b, self->hists->nr_entries);
                        hists__browser_title(self->hists, title, sizeof(title),
-                                            ev_name, self->dso_filter,
-                                            self->thread_filter);
+                                            ev_name);
                        ui_browser__show_title(&self->b, title);
                        continue;
                case 'D': { /* Debug */
 }
 
 static int hists__browser_title(struct hists *self, char *bf, size_t size,
-                               const char *ev_name, const struct dso *dso,
-                               const struct thread *thread)
+                               const char *ev_name)
 {
        char unit;
        int printed;
+       const struct dso *dso = self->dso_filter;
+       const struct thread *thread = self->thread_filter;
        unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
 
        nr_events = convert_unit(nr_events, &unit);
                                continue;
                        }
                        top = pstack__pop(fstack);
-                       if (top == &browser->dso_filter)
+                       if (top == &browser->hists->dso_filter)
                                goto zoom_out_dso;
-                       if (top == &browser->thread_filter)
+                       if (top == &browser->hists->thread_filter)
                                goto zoom_out_thread;
                        continue;
                }
 
                if (thread != NULL &&
                    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
-                            (browser->thread_filter ? "out of" : "into"),
+                            (browser->hists->thread_filter ? "out of" : "into"),
                             (thread->comm_set ? thread->comm : ""),
                             thread->pid) > 0)
                        zoom_thread = nr_options++;
 
                if (dso != NULL &&
                    asprintf(&options[nr_options], "Zoom %s %s DSO",
-                            (browser->dso_filter ? "out of" : "into"),
+                            (browser->hists->dso_filter ? "out of" : "into"),
                             (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
                        zoom_dso = nr_options++;
 
                        map__browse(browser->selection->map);
                else if (choice == zoom_dso) {
 zoom_dso:
-                       if (browser->dso_filter) {
-                               pstack__remove(fstack, &browser->dso_filter);
+                       if (browser->hists->dso_filter) {
+                               pstack__remove(fstack, &browser->hists->dso_filter);
 zoom_out_dso:
                                ui_helpline__pop();
-                               browser->dso_filter = NULL;
+                               browser->hists->dso_filter = NULL;
                        } else {
                                if (dso == NULL)
                                        continue;
                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
                                                   dso->kernel ? "the Kernel" : dso->short_name);
-                               browser->dso_filter = dso;
-                               pstack__push(fstack, &browser->dso_filter);
+                               browser->hists->dso_filter = dso;
+                               pstack__push(fstack, &browser->hists->dso_filter);
                        }
-                       hists__filter_by_dso(self, browser->dso_filter);
+                       hists__filter_by_dso(self);
                        hist_browser__reset(browser);
                } else if (choice == zoom_thread) {
 zoom_thread:
-                       if (browser->thread_filter) {
-                               pstack__remove(fstack, &browser->thread_filter);
+                       if (browser->hists->thread_filter) {
+                               pstack__remove(fstack, &browser->hists->thread_filter);
 zoom_out_thread:
                                ui_helpline__pop();
-                               browser->thread_filter = NULL;
+                               browser->hists->thread_filter = NULL;
                        } else {
                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
                                                   thread->comm_set ? thread->comm : "",
                                                   thread->pid);
-                               browser->thread_filter = thread;
-                               pstack__push(fstack, &browser->thread_filter);
+                               browser->hists->thread_filter = thread;
+                               pstack__push(fstack, &browser->hists->thread_filter);
                        }
-                       hists__filter_by_thread(self, browser->thread_filter);
+                       hists__filter_by_thread(self);
                        hist_browser__reset(browser);
                }
        }