← Back to branch summary

~noskcaj/ubuntu/wily/epiphany-browser/merge

« back to all changes in this revision

Viewing changes to embed/ephy-adblock-manager.c

  • Committer: Package Import Robot
  • Author(s): Gustavo Noronha Silva
  • Date: 2013-03-20 20:45:41 UTC
  • mto: (120.1.2 experimental) (1.10.1) (105.1.14 sid)
  • mto: This revision was merged to the branch mainline in revision 121.
  • Revision ID: package-import@ubuntu.com-20130320204541-0t2adqjzvpflkni2
Tags: upstream-3.7.91
Import upstream version 3.7.91

Show diffs side-by-side

added added

removed removed

Lines of Context:
embed/ephy-adblock-manager.c
 
1
/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
1
2
/*
2
3
 *  Copyright © 2003 Marco Pesenti Gritti
3
4
 *  Copyright © 2003 Christian Persch
20
21
 */
21
22
 
22
23
#include "config.h"
23
 
#include "ephy-debug.h"
24
 
 
25
24
#include "ephy-adblock-manager.h"
 
25
 
26
26
#include "ephy-adblock.h"
 
27
#include "ephy-debug.h"
27
28
 
28
29
struct _EphyAdBlockManagerPrivate
29
30
{
30
 
        EphyAdBlock *blocker;
 
31
  EphyAdBlock *blocker;
31
32
};
32
33
 
33
34
G_DEFINE_TYPE (EphyAdBlockManager, ephy_adblock_manager, G_TYPE_OBJECT);
34
35
 
35
 
#define EPHY_ADBLOCK_MANAGER_GET_PRIVATE(object) \
36
 
        (G_TYPE_INSTANCE_GET_PRIVATE ((object), \
37
 
         EPHY_TYPE_ADBLOCK_MANAGER, EphyAdBlockManagerPrivate))
38
 
 
 
36
#define EPHY_ADBLOCK_MANAGER_GET_PRIVATE(object) (G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_ADBLOCK_MANAGER, EphyAdBlockManagerPrivate))
39
37
 
40
38
/**
41
39
 * ephy_adblock_manager_set_blocker:
48
46
 **/
49
47
void
50
48
ephy_adblock_manager_set_blocker (EphyAdBlockManager *self,
51
 
                                  EphyAdBlock *blocker)
 
49
                                  EphyAdBlock *blocker)
52
50
{
53
 
        self->priv->blocker = blocker;
 
51
  g_return_if_fail (EPHY_IS_ADBLOCK_MANAGER (self));
 
52
  g_return_if_fail (EPHY_IS_ADBLOCK (blocker));
 
53
 
 
54
  self->priv->blocker = blocker;
54
55
}
55
56
 
56
57
/**
65
66
 **/
66
67
gboolean
67
68
ephy_adblock_manager_should_load (EphyAdBlockManager *self,
68
 
                                  EphyEmbed *embed,
69
 
                                  const char *url,
70
 
                                  AdUriCheckType check_type)
 
69
                                  EphyEmbed *embed,
 
70
                                  const char *url,
 
71
                                  AdUriCheckType check_type)
71
72
{
72
 
        if (self->priv->blocker != NULL)
73
 
        {
74
 
                return ephy_adblock_should_load (self->priv->blocker,   
75
 
                                                 embed,
76
 
                                                 url,
77
 
                                                 check_type);
78
 
        }
79
 
 
80
 
        /* default: let's process any url */
81
 
        return TRUE;
 
73
  g_return_val_if_fail (EPHY_IS_ADBLOCK_MANAGER (self), TRUE);
 
74
  g_return_val_if_fail (EPHY_IS_EMBED (embed), TRUE);
 
75
  g_return_val_if_fail (url, TRUE);
 
76
 
 
77
  if (self->priv->blocker != NULL)
 
78
    return ephy_adblock_should_load (self->priv->blocker, 
 
79
                                     embed,
 
80
                                     url,
 
81
                                     check_type);
 
82
 
 
83
  /* Default: let's process any url. */
 
84
  return TRUE;
82
85
}
83
86
 
84
87
static void
85
88
ephy_adblock_manager_init (EphyAdBlockManager *self)
86
89
{
87
 
        LOG ("ephy_adblock_manager_init");
 
90
  LOG ("ephy_adblock_manager_init");
88
91
 
89
 
        self->priv = EPHY_ADBLOCK_MANAGER_GET_PRIVATE(self);
 
92
  self->priv = EPHY_ADBLOCK_MANAGER_GET_PRIVATE(self);
90
93
}
91
94
 
92
95
static void
93
96
ephy_adblock_manager_class_init (EphyAdBlockManagerClass *klass)
94
97
{
95
 
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
96
 
 
97
 
        g_signal_new ("rules_changed",
98
 
                      G_OBJECT_CLASS_TYPE (object_class),
99
 
                      G_SIGNAL_RUN_FIRST,
100
 
                      G_STRUCT_OFFSET (EphyAdBlockManagerClass, rules_changed),
101
 
                      NULL, NULL,
102
 
                      g_cclosure_marshal_VOID__VOID,
103
 
                      G_TYPE_NONE,
104
 
                      0,
105
 
                      0);
106
 
 
107
 
        g_type_class_add_private (object_class, sizeof (EphyAdBlockManagerPrivate));
108
 
}
109
 
 
110
 
/**
111
 
 * ephy_adblock_manager_edit_rule:
112
 
 * @shell: a #EphyAdBlockManager
113
 
 * @url: the target url on which the rule is based
114
 
 * @allowed: TRUE if the url has to be blocked.
115
 
 *
116
 
 * Ask to the blocker a new rule based on @url.
117
 
 *
118
 
 **/
119
 
void
120
 
ephy_adblock_manager_edit_rule (EphyAdBlockManager *self,
121
 
                                const char *url,
122
 
                                gboolean allowed)
123
 
{
124
 
        if (self->priv->blocker != NULL)
125
 
        {
126
 
                ephy_adblock_edit_rule (self->priv->blocker,    
127
 
                                        url,
128
 
                                        allowed);
129
 
        }
 
98
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
99
 
 
100
  g_signal_new ("rules_changed",
 
101
                G_OBJECT_CLASS_TYPE (object_class),
 
102
                G_SIGNAL_RUN_FIRST,
 
103
                G_STRUCT_OFFSET (EphyAdBlockManagerClass, rules_changed),
 
104
                NULL, NULL,
 
105
                g_cclosure_marshal_VOID__VOID,
 
106
                G_TYPE_NONE,
 
107
                0,
 
108
                0);
 
109
 
 
110
  g_type_class_add_private (object_class, sizeof (EphyAdBlockManagerPrivate));
130
111
}
131
112
 
132
113
/**
140
121
gboolean
141
122
ephy_adblock_manager_has_blocker (EphyAdBlockManager *self)
142
123
{
143
 
        return self->priv->blocker != NULL;
 
124
  g_return_val_if_fail (EPHY_IS_ADBLOCK_MANAGER (self), FALSE);
 
125
 
 
126
  return self->priv->blocker != NULL;
144
127
}